# komle/bindings/v1411/write/_nsgroup.py
# -*- coding: utf-8 -*-
# PyXB bindings for NGM:31dc9d33ae09dae9cd9938ac948b7eee03f73812
# Generated 2020-05-05 12:37:19.643879 by PyXB version 1.2.6 using Python 3.8.2.final.0
# Group contents:
# Namespace http://www.isotc211.org/2005/gco [xmlns:gco]
# Namespace http://www.isotc211.org/2005/gmd [xmlns:gmd]
# Namespace http://www.isotc211.org/2005/gsr [xmlns:gsr]
# Namespace http://www.isotc211.org/2005/gss [xmlns:gss]
# Namespace http://www.isotc211.org/2005/gts [xmlns:gts]
# Namespace http://www.opengis.net/gml/3.2 [xmlns:gml]


from __future__ import unicode_literals

import pyxb
import pyxb.binding
import pyxb.utils.six as _six
import pyxb.utils.utility

# Unique identifier for bindings created at the same time
_GenerationUID = pyxb.utils.utility.UniqueIdentifier('urn:uuid:23c8451a-8ebc-11ea-ae29-f507f064c4f5')

# Version of PyXB used to generate the bindings
_PyXBVersion = '1.2.6'
# Generated bindings are not compatible across PyXB versions
if pyxb.__version__ != _PyXBVersion:
    raise pyxb.PyXBVersionError(_PyXBVersion)

# A holder for module-level binding classes so we can access them from
# inside class definitions where property names may conflict.
_module_typeBindings = pyxb.utils.utility.Object()

# Import bindings for namespaces imported into schema
import pyxb.binding.datatypes

import komle.bindings.v1411.write._xlink as _ImportedBinding_bindings_v1411_write__xlink

# NOTE: All namespace declarations are reserved within the binding
_Namespace_gco = pyxb.namespace.NamespaceForURI('http://www.isotc211.org/2005/gco', create_if_missing=True)
_Namespace_gco.configureCategories(['typeBinding', 'elementBinding'])
_Namespace_gmd = pyxb.namespace.NamespaceForURI('http://www.isotc211.org/2005/gmd', create_if_missing=True)
_Namespace_gmd.configureCategories(['typeBinding', 'elementBinding'])
_Namespace_gml = pyxb.namespace.NamespaceForURI('http://www.opengis.net/gml/3.2', create_if_missing=True)
_Namespace_gml.configureCategories(['typeBinding', 'elementBinding'])
_Namespace_xlink = _ImportedBinding_bindings_v1411_write__xlink.Namespace
_Namespace_xlink.configureCategories(['typeBinding', 'elementBinding'])
_Namespace_gsr = pyxb.namespace.NamespaceForURI('http://www.isotc211.org/2005/gsr', create_if_missing=True)
_Namespace_gsr.configureCategories(['typeBinding', 'elementBinding'])
_Namespace_gss = pyxb.namespace.NamespaceForURI('http://www.isotc211.org/2005/gss', create_if_missing=True)
_Namespace_gss.configureCategories(['typeBinding', 'elementBinding'])
_Namespace_gts = pyxb.namespace.NamespaceForURI('http://www.isotc211.org/2005/gts', create_if_missing=True)
_Namespace_gts.configureCategories(['typeBinding', 'elementBinding'])

# Union simple type: {http://www.isotc211.org/2005/gco}Date_Type
# superclasses pyxb.binding.datatypes.anySimpleType
class Date_Type (pyxb.binding.basis.STD_union):

    """Simple type that is a union of pyxb.binding.datatypes.date, pyxb.binding.datatypes.gYearMonth, pyxb.binding.datatypes.gYear."""

    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gco, 'Date_Type')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 304, 1)
    _Documentation = None

    _MemberTypes = ( pyxb.binding.datatypes.date, pyxb.binding.datatypes.gYearMonth, pyxb.binding.datatypes.gYear, )
Date_Type._CF_pattern = pyxb.binding.facets.CF_pattern()
Date_Type._CF_enumeration = pyxb.binding.facets.CF_enumeration(value_datatype=Date_Type)
Date_Type._InitializeFacetMap(Date_Type._CF_pattern,
   Date_Type._CF_enumeration)
_Namespace_gco.addCategoryObject('typeBinding', 'Date_Type', Date_Type)
_module_typeBindings.Date_Type = Date_Type

# Atomic simple type: {http://www.isotc211.org/2005/gmd}MD_TopicCategoryCode_Type
class MD_TopicCategoryCode_Type (pyxb.binding.datatypes.string, pyxb.binding.basis.enumeration_mixin):

    """High-level geospatial data thematic classification to assist in the grouping and search of available geospatial datasets"""

    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_TopicCategoryCode_Type')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 253, 1)
    _Documentation = 'High-level geospatial data thematic classification to assist in the grouping and search of available geospatial datasets'
MD_TopicCategoryCode_Type._CF_enumeration = pyxb.binding.facets.CF_enumeration(value_datatype=MD_TopicCategoryCode_Type, enum_prefix=None)
MD_TopicCategoryCode_Type.farming = MD_TopicCategoryCode_Type._CF_enumeration.addEnumeration(unicode_value='farming', tag='farming')
MD_TopicCategoryCode_Type.biota = MD_TopicCategoryCode_Type._CF_enumeration.addEnumeration(unicode_value='biota', tag='biota')
MD_TopicCategoryCode_Type.boundaries = MD_TopicCategoryCode_Type._CF_enumeration.addEnumeration(unicode_value='boundaries', tag='boundaries')
MD_TopicCategoryCode_Type.climatologyMeteorologyAtmosphere = MD_TopicCategoryCode_Type._CF_enumeration.addEnumeration(unicode_value='climatologyMeteorologyAtmosphere', tag='climatologyMeteorologyAtmosphere')
MD_TopicCategoryCode_Type.economy = MD_TopicCategoryCode_Type._CF_enumeration.addEnumeration(unicode_value='economy', tag='economy')
MD_TopicCategoryCode_Type.elevation = MD_TopicCategoryCode_Type._CF_enumeration.addEnumeration(unicode_value='elevation', tag='elevation')
MD_TopicCategoryCode_Type.environment = MD_TopicCategoryCode_Type._CF_enumeration.addEnumeration(unicode_value='environment', tag='environment')
MD_TopicCategoryCode_Type.geoscientificInformation = MD_TopicCategoryCode_Type._CF_enumeration.addEnumeration(unicode_value='geoscientificInformation', tag='geoscientificInformation')
MD_TopicCategoryCode_Type.health = MD_TopicCategoryCode_Type._CF_enumeration.addEnumeration(unicode_value='health', tag='health')
MD_TopicCategoryCode_Type.imageryBaseMapsEarthCover = MD_TopicCategoryCode_Type._CF_enumeration.addEnumeration(unicode_value='imageryBaseMapsEarthCover', tag='imageryBaseMapsEarthCover')
MD_TopicCategoryCode_Type.intelligenceMilitary = MD_TopicCategoryCode_Type._CF_enumeration.addEnumeration(unicode_value='intelligenceMilitary', tag='intelligenceMilitary')
MD_TopicCategoryCode_Type.inlandWaters = MD_TopicCategoryCode_Type._CF_enumeration.addEnumeration(unicode_value='inlandWaters', tag='inlandWaters')
MD_TopicCategoryCode_Type.location = MD_TopicCategoryCode_Type._CF_enumeration.addEnumeration(unicode_value='location', tag='location')
MD_TopicCategoryCode_Type.oceans = MD_TopicCategoryCode_Type._CF_enumeration.addEnumeration(unicode_value='oceans', tag='oceans')
MD_TopicCategoryCode_Type.planningCadastre = MD_TopicCategoryCode_Type._CF_enumeration.addEnumeration(unicode_value='planningCadastre', tag='planningCadastre')
MD_TopicCategoryCode_Type.society = MD_TopicCategoryCode_Type._CF_enumeration.addEnumeration(unicode_value='society', tag='society')
MD_TopicCategoryCode_Type.structure = MD_TopicCategoryCode_Type._CF_enumeration.addEnumeration(unicode_value='structure', tag='structure')
MD_TopicCategoryCode_Type.transportation = MD_TopicCategoryCode_Type._CF_enumeration.addEnumeration(unicode_value='transportation', tag='transportation')
MD_TopicCategoryCode_Type.utilitiesCommunication = MD_TopicCategoryCode_Type._CF_enumeration.addEnumeration(unicode_value='utilitiesCommunication', tag='utilitiesCommunication')
MD_TopicCategoryCode_Type._InitializeFacetMap(MD_TopicCategoryCode_Type._CF_enumeration)
_Namespace_gmd.addCategoryObject('typeBinding', 'MD_TopicCategoryCode_Type', MD_TopicCategoryCode_Type)
_module_typeBindings.MD_TopicCategoryCode_Type = MD_TopicCategoryCode_Type

# Atomic simple type: {http://www.isotc211.org/2005/gmd}MD_ObligationCode_Type
class MD_ObligationCode_Type (pyxb.binding.datatypes.string, pyxb.binding.basis.enumeration_mixin):

    """An atomic simple type."""

    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_ObligationCode_Type')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataExtension.xsd', 73, 1)
    _Documentation = None
MD_ObligationCode_Type._CF_enumeration = pyxb.binding.facets.CF_enumeration(value_datatype=MD_ObligationCode_Type, enum_prefix=None)
MD_ObligationCode_Type.mandatory = MD_ObligationCode_Type._CF_enumeration.addEnumeration(unicode_value='mandatory', tag='mandatory')
MD_ObligationCode_Type.optional = MD_ObligationCode_Type._CF_enumeration.addEnumeration(unicode_value='optional', tag='optional')
MD_ObligationCode_Type.conditional = MD_ObligationCode_Type._CF_enumeration.addEnumeration(unicode_value='conditional', tag='conditional')
MD_ObligationCode_Type._InitializeFacetMap(MD_ObligationCode_Type._CF_enumeration)
_Namespace_gmd.addCategoryObject('typeBinding', 'MD_ObligationCode_Type', MD_ObligationCode_Type)
_module_typeBindings.MD_ObligationCode_Type = MD_ObligationCode_Type

# Atomic simple type: {http://www.isotc211.org/2005/gmd}MD_PixelOrientationCode_Type
class MD_PixelOrientationCode_Type (pyxb.binding.datatypes.string, pyxb.binding.basis.enumeration_mixin):

    """An atomic simple type."""

    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_PixelOrientationCode_Type')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/spatialRepresentation.xsd', 179, 1)
    _Documentation = None
MD_PixelOrientationCode_Type._CF_enumeration = pyxb.binding.facets.CF_enumeration(value_datatype=MD_PixelOrientationCode_Type, enum_prefix=None)
MD_PixelOrientationCode_Type.center = MD_PixelOrientationCode_Type._CF_enumeration.addEnumeration(unicode_value='center', tag='center')
MD_PixelOrientationCode_Type.lowerLeft = MD_PixelOrientationCode_Type._CF_enumeration.addEnumeration(unicode_value='lowerLeft', tag='lowerLeft')
MD_PixelOrientationCode_Type.lowerRight = MD_PixelOrientationCode_Type._CF_enumeration.addEnumeration(unicode_value='lowerRight', tag='lowerRight')
MD_PixelOrientationCode_Type.upperRight = MD_PixelOrientationCode_Type._CF_enumeration.addEnumeration(unicode_value='upperRight', tag='upperRight')
MD_PixelOrientationCode_Type.upperLeft = MD_PixelOrientationCode_Type._CF_enumeration.addEnumeration(unicode_value='upperLeft', tag='upperLeft')
MD_PixelOrientationCode_Type._InitializeFacetMap(MD_PixelOrientationCode_Type._CF_enumeration)
_Namespace_gmd.addCategoryObject('typeBinding', 'MD_PixelOrientationCode_Type', MD_PixelOrientationCode_Type)
_module_typeBindings.MD_PixelOrientationCode_Type = MD_PixelOrientationCode_Type

# Atomic simple type: [anonymous]
class STD_ANON (pyxb.binding.datatypes.string, pyxb.binding.basis.enumeration_mixin):

    """An atomic simple type."""

    _ExpandedName = None
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/basicTypes.xsd', 37, 3)
    _Documentation = None
STD_ANON._CF_enumeration = pyxb.binding.facets.CF_enumeration(value_datatype=STD_ANON, enum_prefix=None)
STD_ANON.inapplicable = STD_ANON._CF_enumeration.addEnumeration(unicode_value='inapplicable', tag='inapplicable')
STD_ANON.missing = STD_ANON._CF_enumeration.addEnumeration(unicode_value='missing', tag='missing')
STD_ANON.template = STD_ANON._CF_enumeration.addEnumeration(unicode_value='template', tag='template')
STD_ANON.unknown = STD_ANON._CF_enumeration.addEnumeration(unicode_value='unknown', tag='unknown')
STD_ANON.withheld = STD_ANON._CF_enumeration.addEnumeration(unicode_value='withheld', tag='withheld')
STD_ANON._InitializeFacetMap(STD_ANON._CF_enumeration)
_module_typeBindings.STD_ANON = STD_ANON

# Atomic simple type: [anonymous]
class STD_ANON_ (pyxb.binding.datatypes.string):

    """An atomic simple type."""

    _ExpandedName = None
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/basicTypes.xsd', 46, 3)
    _Documentation = None
STD_ANON_._CF_pattern = pyxb.binding.facets.CF_pattern()
STD_ANON_._CF_pattern.addPattern(pattern='other:\\w{2,}')
STD_ANON_._InitializeFacetMap(STD_ANON_._CF_pattern)
_module_typeBindings.STD_ANON_ = STD_ANON_

# Atomic simple type: {http://www.opengis.net/gml/3.2}SignType
class SignType (pyxb.binding.datatypes.string, pyxb.binding.basis.enumeration_mixin):

    """gml:SignType is a convenience type with values "+" (plus) and "-" (minus)."""

    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'SignType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/basicTypes.xsd', 53, 1)
    _Documentation = 'gml:SignType is a convenience type with values "+" (plus) and "-" (minus).'
SignType._CF_enumeration = pyxb.binding.facets.CF_enumeration(value_datatype=SignType, enum_prefix=None)
SignType.emptyString = SignType._CF_enumeration.addEnumeration(unicode_value='-', tag='emptyString')
SignType.emptyString_ = SignType._CF_enumeration.addEnumeration(unicode_value='+', tag='emptyString_')
SignType._InitializeFacetMap(SignType._CF_enumeration)
_Namespace_gml.addCategoryObject('typeBinding', 'SignType', SignType)
_module_typeBindings.SignType = SignType

# Atomic simple type: [anonymous]
class STD_ANON_2 (pyxb.binding.datatypes.string):

    """An atomic simple type."""

    _ExpandedName = None
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/basicTypes.xsd', 103, 1)
    _Documentation = None
STD_ANON_2._InitializeFacetMap()
_module_typeBindings.STD_ANON_2 = STD_ANON_2

# Atomic simple type: {http://www.opengis.net/gml/3.2}UomSymbol
class UomSymbol (pyxb.binding.datatypes.string):

    """This type specifies a character string of length at least one, and restricted such that it must not contain any of the following characters: ":" (colon), " " (space), (newline), (carriage return), (tab). This allows values corresponding to familiar abbreviations, such as "kg", "m/s", etc. 
It is recommended that the symbol be an identifier for a unit of measure as specified in the "Unified Code of Units of Measure" (UCUM) (http://aurora.regenstrief.org/UCUM). This provides a set of symbols and a grammar for constructing identifiers for units of measure that are unique, and may be easily entered with a keyboard supporting the limited character set known as 7-bit ASCII. ISO 2955 formerly provided a specification with this scope, but was withdrawn in 2001. UCUM largely follows ISO 2955 with modifications to remove ambiguities and other problems."""

    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'UomSymbol')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/basicTypes.xsd', 129, 1)
    _Documentation = 'This type specifies a character string of length at least one, and restricted such that it must not contain any of the following characters: ":" (colon), " " (space), (newline), (carriage return), (tab). This allows values corresponding to familiar abbreviations, such as "kg", "m/s", etc. \nIt is recommended that the symbol be an identifier for a unit of measure as specified in the "Unified Code of Units of Measure" (UCUM) (http://aurora.regenstrief.org/UCUM). This provides a set of symbols and a grammar for constructing identifiers for units of measure that are unique, and may be easily entered with a keyboard supporting the limited character set known as 7-bit ASCII. ISO 2955 formerly provided a specification with this scope, but was withdrawn in 2001. UCUM largely follows ISO 2955 with modifications to remove ambiguities and other problems.'
UomSymbol._CF_pattern = pyxb.binding.facets.CF_pattern()
UomSymbol._CF_pattern.addPattern(pattern='[^: \\n\\r\\t]+')
UomSymbol._InitializeFacetMap(UomSymbol._CF_pattern)
_Namespace_gml.addCategoryObject('typeBinding', 'UomSymbol', UomSymbol)
_module_typeBindings.UomSymbol = UomSymbol

# Atomic simple type: {http://www.opengis.net/gml/3.2}UomURI
class UomURI (pyxb.binding.datatypes.anyURI):

    """This type specifies a URI, restricted such that it must start with one of the following sequences: "#", "./", "../", or a string of characters followed by a ":". These patterns ensure that the most common URI forms are supported, including absolute and relative URIs and URIs that are simple fragment identifiers, but prohibits certain forms of relative URI that could be mistaken for unit of measure symbol . 
NOTE	It is possible to re-write such a relative URI to conform to the restriction (e.g. "./m/s").
In an instance document, on elements of type gml:MeasureType the mandatory uom attribute shall carry a value corresponding to either 
-	a conventional unit of measure symbol,
-	a link to a definition of a unit of measure that does not have a conventional symbol, or when it is desired to indicate a precise or variant definition."""

    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'UomURI')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/basicTypes.xsd', 138, 1)
    _Documentation = 'This type specifies a URI, restricted such that it must start with one of the following sequences: "#", "./", "../", or a string of characters followed by a ":". These patterns ensure that the most common URI forms are supported, including absolute and relative URIs and URIs that are simple fragment identifiers, but prohibits certain forms of relative URI that could be mistaken for unit of measure symbol . \nNOTE\tIt is possible to re-write such a relative URI to conform to the restriction (e.g. "./m/s").\nIn an instance document, on elements of type gml:MeasureType the mandatory uom attribute shall carry a value corresponding to either \n-\ta conventional unit of measure symbol,\n-\ta link to a definition of a unit of measure that does not have a conventional symbol, or when it is desired to indicate a precise or variant definition.'
UomURI._CF_pattern = pyxb.binding.facets.CF_pattern()
UomURI._CF_pattern.addPattern(pattern='([a-zA-Z][a-zA-Z0-9\\-\\+\\.]*:|\\.\\./|\\./|#).*')
UomURI._InitializeFacetMap(UomURI._CF_pattern)
_Namespace_gml.addCategoryObject('typeBinding', 'UomURI', UomURI)
_module_typeBindings.UomURI = UomURI

# List simple type: {http://www.opengis.net/gml/3.2}booleanList
# superclasses pyxb.binding.datatypes.anySimpleType
class booleanList (pyxb.binding.basis.STD_list):

    """A type for a list of values of the respective simple type."""

    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'booleanList')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/basicTypes.xsd', 168, 1)
    _Documentation = 'A type for a list of values of the respective simple type.'

    _ItemType = pyxb.binding.datatypes.boolean
booleanList._InitializeFacetMap()
_Namespace_gml.addCategoryObject('typeBinding', 'booleanList', booleanList)
_module_typeBindings.booleanList = booleanList

# List simple type: {http://www.opengis.net/gml/3.2}doubleList
# superclasses pyxb.binding.datatypes.anySimpleType
class doubleList (pyxb.binding.basis.STD_list):

    """A type for a list of values of the respective simple type."""

    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'doubleList')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/basicTypes.xsd', 174, 1)
    _Documentation = 'A type for a list of values of the respective simple type.'

    _ItemType = pyxb.binding.datatypes.double
doubleList._InitializeFacetMap()
_Namespace_gml.addCategoryObject('typeBinding', 'doubleList', doubleList)
_module_typeBindings.doubleList = doubleList

# List simple type: {http://www.opengis.net/gml/3.2}integerList
# superclasses pyxb.binding.datatypes.anySimpleType
class integerList (pyxb.binding.basis.STD_list):

    """A type for a list of values of the respective simple type."""

    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'integerList')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/basicTypes.xsd', 180, 1)
    _Documentation = 'A type for a list of values of the respective simple type.'

    _ItemType = pyxb.binding.datatypes.integer
integerList._InitializeFacetMap()
_Namespace_gml.addCategoryObject('typeBinding', 'integerList', integerList)
_module_typeBindings.integerList = integerList

# List simple type: {http://www.opengis.net/gml/3.2}NameList
# superclasses pyxb.binding.datatypes.anySimpleType
class NameList (pyxb.binding.basis.STD_list):

    """A type for a list of values of the respective simple type."""

    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'NameList')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/basicTypes.xsd', 186, 1)
    _Documentation = 'A type for a list of values of the respective simple type.'

    _ItemType = pyxb.binding.datatypes.Name
NameList._InitializeFacetMap()
_Namespace_gml.addCategoryObject('typeBinding', 'NameList', NameList)
_module_typeBindings.NameList = NameList

# List simple type: {http://www.opengis.net/gml/3.2}NCNameList
# superclasses pyxb.binding.datatypes.anySimpleType
class NCNameList (pyxb.binding.basis.STD_list):

    """A type for a list of values of the respective simple type."""

    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'NCNameList')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/basicTypes.xsd', 192, 1)
    _Documentation = 'A type for a list of values of the respective simple type.'

    _ItemType = pyxb.binding.datatypes.NCName
NCNameList._InitializeFacetMap()
_Namespace_gml.addCategoryObject('typeBinding', 'NCNameList', NCNameList)
_module_typeBindings.NCNameList = NCNameList

# List simple type: {http://www.opengis.net/gml/3.2}QNameList
# superclasses pyxb.binding.datatypes.anySimpleType
class QNameList (pyxb.binding.basis.STD_list):

    """A type for a list of values of the respective simple type."""

    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'QNameList')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/basicTypes.xsd', 198, 1)
    _Documentation = 'A type for a list of values of the respective simple type.'

    _ItemType = pyxb.binding.datatypes.QName
QNameList._InitializeFacetMap()
_Namespace_gml.addCategoryObject('typeBinding', 'QNameList', QNameList)
_module_typeBindings.QNameList = QNameList

# Atomic simple type: {http://www.opengis.net/gml/3.2}SequenceRuleEnumeration
class SequenceRuleEnumeration (pyxb.binding.datatypes.string, pyxb.binding.basis.enumeration_mixin):

    """An atomic simple type."""

    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'SequenceRuleEnumeration')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coverage.xsd', 212, 1)
    _Documentation = None
SequenceRuleEnumeration._CF_enumeration = pyxb.binding.facets.CF_enumeration(value_datatype=SequenceRuleEnumeration, enum_prefix=None)
SequenceRuleEnumeration.Linear = SequenceRuleEnumeration._CF_enumeration.addEnumeration(unicode_value='Linear', tag='Linear')
SequenceRuleEnumeration.Boustrophedonic = SequenceRuleEnumeration._CF_enumeration.addEnumeration(unicode_value='Boustrophedonic', tag='Boustrophedonic')
SequenceRuleEnumeration.Cantor_diagonal = SequenceRuleEnumeration._CF_enumeration.addEnumeration(unicode_value='Cantor-diagonal', tag='Cantor_diagonal')
SequenceRuleEnumeration.Spiral = SequenceRuleEnumeration._CF_enumeration.addEnumeration(unicode_value='Spiral', tag='Spiral')
SequenceRuleEnumeration.Morton = SequenceRuleEnumeration._CF_enumeration.addEnumeration(unicode_value='Morton', tag='Morton')
SequenceRuleEnumeration.Hilbert = SequenceRuleEnumeration._CF_enumeration.addEnumeration(unicode_value='Hilbert', tag='Hilbert')
SequenceRuleEnumeration._InitializeFacetMap(SequenceRuleEnumeration._CF_enumeration)
_Namespace_gml.addCategoryObject('typeBinding', 'SequenceRuleEnumeration', SequenceRuleEnumeration)
_module_typeBindings.SequenceRuleEnumeration = SequenceRuleEnumeration

# Atomic simple type: {http://www.opengis.net/gml/3.2}AxisDirection
class AxisDirection (pyxb.binding.datatypes.string):

    """The value of a gml:AxisDirection indicates the incrementation order to be used on an axis of the grid."""

    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'AxisDirection')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coverage.xsd', 228, 1)
    _Documentation = 'The value of a gml:AxisDirection indicates the incrementation order to be used on an axis of the grid.'
AxisDirection._CF_pattern = pyxb.binding.facets.CF_pattern()
AxisDirection._CF_pattern.addPattern(pattern='[\\+\\-][1-9][0-9]*')
AxisDirection._InitializeFacetMap(AxisDirection._CF_pattern)
_Namespace_gml.addCategoryObject('typeBinding', 'AxisDirection', AxisDirection)
_module_typeBindings.AxisDirection = AxisDirection

# Atomic simple type: {http://www.opengis.net/gml/3.2}SuccessionType
class SuccessionType (pyxb.binding.datatypes.string, pyxb.binding.basis.enumeration_mixin):

    """An atomic simple type."""

    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'SuccessionType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 523, 1)
    _Documentation = ''
SuccessionType._CF_enumeration = pyxb.binding.facets.CF_enumeration(value_datatype=SuccessionType, enum_prefix=None)
SuccessionType.substitution = SuccessionType._CF_enumeration.addEnumeration(unicode_value='substitution', tag='substitution')
SuccessionType.division = SuccessionType._CF_enumeration.addEnumeration(unicode_value='division', tag='division')
SuccessionType.fusion = SuccessionType._CF_enumeration.addEnumeration(unicode_value='fusion', tag='fusion')
SuccessionType.initiation = SuccessionType._CF_enumeration.addEnumeration(unicode_value='initiation', tag='initiation')
SuccessionType._InitializeFacetMap(SuccessionType._CF_enumeration)
_Namespace_gml.addCategoryObject('typeBinding', 'SuccessionType', SuccessionType)
_module_typeBindings.SuccessionType = SuccessionType

# Atomic simple type: [anonymous]
class STD_ANON_3 (pyxb.binding.datatypes.string, pyxb.binding.basis.enumeration_mixin):

    """An atomic simple type."""

    _ExpandedName = None
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 566, 5)
    _Documentation = None
STD_ANON_3._CF_enumeration = pyxb.binding.facets.CF_enumeration(value_datatype=STD_ANON_3, enum_prefix=None)
STD_ANON_3.N = STD_ANON_3._CF_enumeration.addEnumeration(unicode_value='N', tag='N')
STD_ANON_3.E = STD_ANON_3._CF_enumeration.addEnumeration(unicode_value='E', tag='E')
STD_ANON_3.S = STD_ANON_3._CF_enumeration.addEnumeration(unicode_value='S', tag='S')
STD_ANON_3.W = STD_ANON_3._CF_enumeration.addEnumeration(unicode_value='W', tag='W')
STD_ANON_3.emptyString = STD_ANON_3._CF_enumeration.addEnumeration(unicode_value='+', tag='emptyString')
STD_ANON_3.emptyString_ = STD_ANON_3._CF_enumeration.addEnumeration(unicode_value='-', tag='emptyString_')
STD_ANON_3._InitializeFacetMap(STD_ANON_3._CF_enumeration)
_module_typeBindings.STD_ANON_3 = STD_ANON_3

# Atomic simple type: {http://www.opengis.net/gml/3.2}DegreeValueType
class DegreeValueType (pyxb.binding.datatypes.nonNegativeInteger):

    """An atomic simple type."""

    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'DegreeValueType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 580, 1)
    _Documentation = ''
DegreeValueType._CF_maxInclusive = pyxb.binding.facets.CF_maxInclusive(value_datatype=DegreeValueType, value=pyxb.binding.datatypes.nonNegativeInteger(359))
DegreeValueType._InitializeFacetMap(DegreeValueType._CF_maxInclusive)
_Namespace_gml.addCategoryObject('typeBinding', 'DegreeValueType', DegreeValueType)
_module_typeBindings.DegreeValueType = DegreeValueType

# Atomic simple type: {http://www.opengis.net/gml/3.2}DecimalMinutesType
class DecimalMinutesType (pyxb.binding.datatypes.decimal):

    """An atomic simple type."""

    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'DecimalMinutesType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 593, 1)
    _Documentation = ''
DecimalMinutesType._CF_minInclusive = pyxb.binding.facets.CF_minInclusive(value_datatype=DecimalMinutesType, value=pyxb.binding.datatypes.decimal('0.0'))
DecimalMinutesType._CF_maxExclusive = pyxb.binding.facets.CF_maxExclusive(value_datatype=pyxb.binding.datatypes.decimal, value=pyxb.binding.datatypes.anySimpleType('60.00'))
DecimalMinutesType._InitializeFacetMap(DecimalMinutesType._CF_minInclusive,
   DecimalMinutesType._CF_maxExclusive)
_Namespace_gml.addCategoryObject('typeBinding', 'DecimalMinutesType', DecimalMinutesType)
_module_typeBindings.DecimalMinutesType = DecimalMinutesType

# Atomic simple type: {http://www.opengis.net/gml/3.2}ArcMinutesType
class ArcMinutesType (pyxb.binding.datatypes.nonNegativeInteger):

    """An atomic simple type."""

    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'ArcMinutesType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 607, 1)
    _Documentation = ''
ArcMinutesType._CF_maxInclusive = pyxb.binding.facets.CF_maxInclusive(value_datatype=ArcMinutesType, value=pyxb.binding.datatypes.nonNegativeInteger(59))
ArcMinutesType._InitializeFacetMap(ArcMinutesType._CF_maxInclusive)
_Namespace_gml.addCategoryObject('typeBinding', 'ArcMinutesType', ArcMinutesType)
_module_typeBindings.ArcMinutesType = ArcMinutesType

# Atomic simple type: {http://www.opengis.net/gml/3.2}ArcSecondsType
class ArcSecondsType (pyxb.binding.datatypes.decimal):

    """An atomic simple type."""

    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'ArcSecondsType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 620, 1)
    _Documentation = ''
ArcSecondsType._CF_minInclusive = pyxb.binding.facets.CF_minInclusive(value_datatype=ArcSecondsType, value=pyxb.binding.datatypes.decimal('0.0'))
ArcSecondsType._CF_maxExclusive = pyxb.binding.facets.CF_maxExclusive(value_datatype=pyxb.binding.datatypes.decimal, value=pyxb.binding.datatypes.anySimpleType('60.00'))
ArcSecondsType._InitializeFacetMap(ArcSecondsType._CF_minInclusive,
   ArcSecondsType._CF_maxExclusive)
_Namespace_gml.addCategoryObject('typeBinding', 'ArcSecondsType', ArcSecondsType)
_module_typeBindings.ArcSecondsType = ArcSecondsType

# Atomic simple type: {http://www.opengis.net/gml/3.2}IncrementOrder
class IncrementOrder (pyxb.binding.datatypes.string, pyxb.binding.basis.enumeration_mixin):

    """An atomic simple type."""

    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'IncrementOrder')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 928, 1)
    _Documentation = ''
IncrementOrder._CF_enumeration = pyxb.binding.facets.CF_enumeration(value_datatype=IncrementOrder, enum_prefix=None)
IncrementOrder.xy = IncrementOrder._CF_enumeration.addEnumeration(unicode_value='+x+y', tag='xy')
IncrementOrder.yx = IncrementOrder._CF_enumeration.addEnumeration(unicode_value='+y+x', tag='yx')
IncrementOrder.x_y = IncrementOrder._CF_enumeration.addEnumeration(unicode_value='+x-y', tag='x_y')
IncrementOrder.x_y_ = IncrementOrder._CF_enumeration.addEnumeration(unicode_value='-x-y', tag='x_y_')
IncrementOrder._InitializeFacetMap(IncrementOrder._CF_enumeration)
_Namespace_gml.addCategoryObject('typeBinding', 'IncrementOrder', IncrementOrder)
_module_typeBindings.IncrementOrder = IncrementOrder

# Atomic simple type: {http://www.opengis.net/gml/3.2}CompassPointEnumeration
class CompassPointEnumeration (pyxb.binding.datatypes.string, pyxb.binding.basis.enumeration_mixin):

    """These directions are necessarily approximate, giving direction with a precision of 22.5°. It is thus generally unnecessary to specify the reference frame, though this may be detailed in the definition of a GML application language."""

    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'CompassPointEnumeration')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/direction.xsd', 61, 1)
    _Documentation = 'These directions are necessarily approximate, giving direction with a precision of 22.5°. It is thus generally unnecessary to specify the reference frame, though this may be detailed in the definition of a GML application language.'
CompassPointEnumeration._CF_enumeration = pyxb.binding.facets.CF_enumeration(value_datatype=CompassPointEnumeration, enum_prefix=None)
CompassPointEnumeration.N = CompassPointEnumeration._CF_enumeration.addEnumeration(unicode_value='N', tag='N')
CompassPointEnumeration.NNE = CompassPointEnumeration._CF_enumeration.addEnumeration(unicode_value='NNE', tag='NNE')
CompassPointEnumeration.NE = CompassPointEnumeration._CF_enumeration.addEnumeration(unicode_value='NE', tag='NE')
CompassPointEnumeration.ENE = CompassPointEnumeration._CF_enumeration.addEnumeration(unicode_value='ENE', tag='ENE')
CompassPointEnumeration.E = CompassPointEnumeration._CF_enumeration.addEnumeration(unicode_value='E', tag='E')
CompassPointEnumeration.ESE = CompassPointEnumeration._CF_enumeration.addEnumeration(unicode_value='ESE', tag='ESE')
CompassPointEnumeration.SE = CompassPointEnumeration._CF_enumeration.addEnumeration(unicode_value='SE', tag='SE')
CompassPointEnumeration.SSE = CompassPointEnumeration._CF_enumeration.addEnumeration(unicode_value='SSE', tag='SSE')
CompassPointEnumeration.S = CompassPointEnumeration._CF_enumeration.addEnumeration(unicode_value='S', tag='S')
CompassPointEnumeration.SSW = CompassPointEnumeration._CF_enumeration.addEnumeration(unicode_value='SSW', tag='SSW')
CompassPointEnumeration.SW = CompassPointEnumeration._CF_enumeration.addEnumeration(unicode_value='SW', tag='SW')
CompassPointEnumeration.WSW = CompassPointEnumeration._CF_enumeration.addEnumeration(unicode_value='WSW', tag='WSW')
CompassPointEnumeration.W = CompassPointEnumeration._CF_enumeration.addEnumeration(unicode_value='W', tag='W')
CompassPointEnumeration.WNW = CompassPointEnumeration._CF_enumeration.addEnumeration(unicode_value='WNW', tag='WNW')
CompassPointEnumeration.NW = CompassPointEnumeration._CF_enumeration.addEnumeration(unicode_value='NW', tag='NW')
CompassPointEnumeration.NNW = CompassPointEnumeration._CF_enumeration.addEnumeration(unicode_value='NNW', tag='NNW')
CompassPointEnumeration._InitializeFacetMap(CompassPointEnumeration._CF_enumeration)
_Namespace_gml.addCategoryObject('typeBinding', 'CompassPointEnumeration', CompassPointEnumeration)
_module_typeBindings.CompassPointEnumeration = CompassPointEnumeration

# Atomic simple type: {http://www.opengis.net/gml/3.2}CurveInterpolationType
class CurveInterpolationType (pyxb.binding.datatypes.string, pyxb.binding.basis.enumeration_mixin):

    """gml:CurveInterpolationType is a list of codes that may be used to identify the interpolation mechanisms specified by an application schema."""

    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'CurveInterpolationType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 78, 1)
    _Documentation = 'gml:CurveInterpolationType is a list of codes that may be used to identify the interpolation mechanisms specified by an application schema.'
CurveInterpolationType._CF_enumeration = pyxb.binding.facets.CF_enumeration(value_datatype=CurveInterpolationType, enum_prefix=None)
CurveInterpolationType.linear = CurveInterpolationType._CF_enumeration.addEnumeration(unicode_value='linear', tag='linear')
CurveInterpolationType.geodesic = CurveInterpolationType._CF_enumeration.addEnumeration(unicode_value='geodesic', tag='geodesic')
CurveInterpolationType.circularArc3Points = CurveInterpolationType._CF_enumeration.addEnumeration(unicode_value='circularArc3Points', tag='circularArc3Points')
CurveInterpolationType.circularArc2PointWithBulge = CurveInterpolationType._CF_enumeration.addEnumeration(unicode_value='circularArc2PointWithBulge', tag='circularArc2PointWithBulge')
CurveInterpolationType.circularArcCenterPointWithRadius = CurveInterpolationType._CF_enumeration.addEnumeration(unicode_value='circularArcCenterPointWithRadius', tag='circularArcCenterPointWithRadius')
CurveInterpolationType.elliptical = CurveInterpolationType._CF_enumeration.addEnumeration(unicode_value='elliptical', tag='elliptical')
CurveInterpolationType.clothoid = CurveInterpolationType._CF_enumeration.addEnumeration(unicode_value='clothoid', tag='clothoid')
CurveInterpolationType.conic = CurveInterpolationType._CF_enumeration.addEnumeration(unicode_value='conic', tag='conic')
CurveInterpolationType.polynomialSpline = CurveInterpolationType._CF_enumeration.addEnumeration(unicode_value='polynomialSpline', tag='polynomialSpline')
CurveInterpolationType.cubicSpline = CurveInterpolationType._CF_enumeration.addEnumeration(unicode_value='cubicSpline', tag='cubicSpline')
CurveInterpolationType.rationalSpline = CurveInterpolationType._CF_enumeration.addEnumeration(unicode_value='rationalSpline', tag='rationalSpline')
CurveInterpolationType._InitializeFacetMap(CurveInterpolationType._CF_enumeration)
_Namespace_gml.addCategoryObject('typeBinding', 'CurveInterpolationType', CurveInterpolationType)
_module_typeBindings.CurveInterpolationType = CurveInterpolationType

# Atomic simple type: {http://www.opengis.net/gml/3.2}KnotTypesType
class KnotTypesType (pyxb.binding.datatypes.string, pyxb.binding.basis.enumeration_mixin):

    """This enumeration type specifies values for the knots' type (see ISO 19107:2003, 6.4.25)."""

    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'KnotTypesType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 373, 1)
    _Documentation = "This enumeration type specifies values for the knots' type (see ISO 19107:2003, 6.4.25)."
KnotTypesType._CF_enumeration = pyxb.binding.facets.CF_enumeration(value_datatype=KnotTypesType, enum_prefix=None)
KnotTypesType.uniform = KnotTypesType._CF_enumeration.addEnumeration(unicode_value='uniform', tag='uniform')
KnotTypesType.quasiUniform = KnotTypesType._CF_enumeration.addEnumeration(unicode_value='quasiUniform', tag='quasiUniform')
KnotTypesType.piecewiseBezier = KnotTypesType._CF_enumeration.addEnumeration(unicode_value='piecewiseBezier', tag='piecewiseBezier')
KnotTypesType._InitializeFacetMap(KnotTypesType._CF_enumeration)
_Namespace_gml.addCategoryObject('typeBinding', 'KnotTypesType', KnotTypesType)
_module_typeBindings.KnotTypesType = KnotTypesType

# Atomic simple type: {http://www.opengis.net/gml/3.2}SurfaceInterpolationType
class SurfaceInterpolationType (pyxb.binding.datatypes.string, pyxb.binding.basis.enumeration_mixin):

    """gml:SurfaceInterpolationType is a list of codes that may be used to identify the interpolation mechanisms specified by an application schema."""

    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'SurfaceInterpolationType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 554, 1)
    _Documentation = 'gml:SurfaceInterpolationType is a list of codes that may be used to identify the interpolation mechanisms specified by an application schema.'
SurfaceInterpolationType._CF_enumeration = pyxb.binding.facets.CF_enumeration(value_datatype=SurfaceInterpolationType, enum_prefix=None)
SurfaceInterpolationType.none = SurfaceInterpolationType._CF_enumeration.addEnumeration(unicode_value='none', tag='none')
SurfaceInterpolationType.planar = SurfaceInterpolationType._CF_enumeration.addEnumeration(unicode_value='planar', tag='planar')
SurfaceInterpolationType.spherical = SurfaceInterpolationType._CF_enumeration.addEnumeration(unicode_value='spherical', tag='spherical')
SurfaceInterpolationType.elliptical = SurfaceInterpolationType._CF_enumeration.addEnumeration(unicode_value='elliptical', tag='elliptical')
SurfaceInterpolationType.conic = SurfaceInterpolationType._CF_enumeration.addEnumeration(unicode_value='conic', tag='conic')
SurfaceInterpolationType.tin = SurfaceInterpolationType._CF_enumeration.addEnumeration(unicode_value='tin', tag='tin')
SurfaceInterpolationType.parametricCurve = SurfaceInterpolationType._CF_enumeration.addEnumeration(unicode_value='parametricCurve', tag='parametricCurve')
SurfaceInterpolationType.polynomialSpline = SurfaceInterpolationType._CF_enumeration.addEnumeration(unicode_value='polynomialSpline', tag='polynomialSpline')
SurfaceInterpolationType.rationalSpline = SurfaceInterpolationType._CF_enumeration.addEnumeration(unicode_value='rationalSpline', tag='rationalSpline')
SurfaceInterpolationType.triangulatedSpline = SurfaceInterpolationType._CF_enumeration.addEnumeration(unicode_value='triangulatedSpline', tag='triangulatedSpline')
SurfaceInterpolationType._InitializeFacetMap(SurfaceInterpolationType._CF_enumeration)
_Namespace_gml.addCategoryObject('typeBinding', 'SurfaceInterpolationType', SurfaceInterpolationType)
_module_typeBindings.SurfaceInterpolationType = SurfaceInterpolationType

# Atomic simple type: {http://www.opengis.net/gml/3.2}AggregationType
class AggregationType (pyxb.binding.datatypes.string, pyxb.binding.basis.enumeration_mixin):

    """An atomic simple type."""

    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'AggregationType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 160, 1)
    _Documentation = None
AggregationType._CF_enumeration = pyxb.binding.facets.CF_enumeration(value_datatype=AggregationType, enum_prefix=None)
AggregationType.set_ = AggregationType._CF_enumeration.addEnumeration(unicode_value='set', tag='set_')
AggregationType.bag = AggregationType._CF_enumeration.addEnumeration(unicode_value='bag', tag='bag')
AggregationType.sequence = AggregationType._CF_enumeration.addEnumeration(unicode_value='sequence', tag='sequence')
AggregationType.array = AggregationType._CF_enumeration.addEnumeration(unicode_value='array', tag='array')
AggregationType.record = AggregationType._CF_enumeration.addEnumeration(unicode_value='record', tag='record')
AggregationType.table = AggregationType._CF_enumeration.addEnumeration(unicode_value='table', tag='table')
AggregationType._InitializeFacetMap(AggregationType._CF_enumeration)
_Namespace_gml.addCategoryObject('typeBinding', 'AggregationType', AggregationType)
_module_typeBindings.AggregationType = AggregationType

# Atomic simple type: [anonymous]
class STD_ANON_4 (pyxb.binding.datatypes.string, pyxb.binding.basis.enumeration_mixin):

    """An atomic simple type."""

    _ExpandedName = None
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporal.xsd', 64, 5)
    _Documentation = None
STD_ANON_4._CF_enumeration = pyxb.binding.facets.CF_enumeration(value_datatype=STD_ANON_4, enum_prefix=None)
STD_ANON_4.Before = STD_ANON_4._CF_enumeration.addEnumeration(unicode_value='Before', tag='Before')
STD_ANON_4.After = STD_ANON_4._CF_enumeration.addEnumeration(unicode_value='After', tag='After')
STD_ANON_4.Begins = STD_ANON_4._CF_enumeration.addEnumeration(unicode_value='Begins', tag='Begins')
STD_ANON_4.Ends = STD_ANON_4._CF_enumeration.addEnumeration(unicode_value='Ends', tag='Ends')
STD_ANON_4.During = STD_ANON_4._CF_enumeration.addEnumeration(unicode_value='During', tag='During')
STD_ANON_4.Equals = STD_ANON_4._CF_enumeration.addEnumeration(unicode_value='Equals', tag='Equals')
STD_ANON_4.Contains = STD_ANON_4._CF_enumeration.addEnumeration(unicode_value='Contains', tag='Contains')
STD_ANON_4.Overlaps = STD_ANON_4._CF_enumeration.addEnumeration(unicode_value='Overlaps', tag='Overlaps')
STD_ANON_4.Meets = STD_ANON_4._CF_enumeration.addEnumeration(unicode_value='Meets', tag='Meets')
STD_ANON_4.OverlappedBy = STD_ANON_4._CF_enumeration.addEnumeration(unicode_value='OverlappedBy', tag='OverlappedBy')
STD_ANON_4.MetBy = STD_ANON_4._CF_enumeration.addEnumeration(unicode_value='MetBy', tag='MetBy')
STD_ANON_4.BegunBy = STD_ANON_4._CF_enumeration.addEnumeration(unicode_value='BegunBy', tag='BegunBy')
STD_ANON_4.EndedBy = STD_ANON_4._CF_enumeration.addEnumeration(unicode_value='EndedBy', tag='EndedBy')
STD_ANON_4._InitializeFacetMap(STD_ANON_4._CF_enumeration)
_module_typeBindings.STD_ANON_4 = STD_ANON_4

# Atomic simple type: {http://www.opengis.net/gml/3.2}TimeIndeterminateValueType
class TimeIndeterminateValueType (pyxb.binding.datatypes.string, pyxb.binding.basis.enumeration_mixin):

    """These values are interpreted as follows: 
-	"unknown" indicates that no specific value for temporal position is provided.
-	"now" indicates that the specified value shall be replaced with the current temporal position whenever the value is accessed.
-	"before" indicates that the actual temporal position is unknown, but it is known to be before the specified value.
-	"after" indicates that the actual temporal position is unknown, but it is known to be after the specified value.
A value for indeterminatePosition may 
-	be used either alone, or 
-	qualify a specific value for temporal position."""

    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'TimeIndeterminateValueType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporal.xsd', 186, 1)
    _Documentation = 'These values are interpreted as follows: \n-\t"unknown" indicates that no specific value for temporal position is provided.\n-\t"now" indicates that the specified value shall be replaced with the current temporal position whenever the value is accessed.\n-\t"before" indicates that the actual temporal position is unknown, but it is known to be before the specified value.\n-\t"after" indicates that the actual temporal position is unknown, but it is known to be after the specified value.\nA value for indeterminatePosition may \n-\tbe used either alone, or \n-\tqualify a specific value for temporal position.'
TimeIndeterminateValueType._CF_enumeration = pyxb.binding.facets.CF_enumeration(value_datatype=TimeIndeterminateValueType, enum_prefix=None)
TimeIndeterminateValueType.after = TimeIndeterminateValueType._CF_enumeration.addEnumeration(unicode_value='after', tag='after')
TimeIndeterminateValueType.before = TimeIndeterminateValueType._CF_enumeration.addEnumeration(unicode_value='before', tag='before')
TimeIndeterminateValueType.now = TimeIndeterminateValueType._CF_enumeration.addEnumeration(unicode_value='now', tag='now')
TimeIndeterminateValueType.unknown = TimeIndeterminateValueType._CF_enumeration.addEnumeration(unicode_value='unknown', tag='unknown')
TimeIndeterminateValueType._InitializeFacetMap(TimeIndeterminateValueType._CF_enumeration)
_Namespace_gml.addCategoryObject('typeBinding', 'TimeIndeterminateValueType', TimeIndeterminateValueType)
_module_typeBindings.TimeIndeterminateValueType = TimeIndeterminateValueType

# Union simple type: {http://www.opengis.net/gml/3.2}TimePositionUnion
# superclasses pyxb.binding.datatypes.anySimpleType
class TimePositionUnion (pyxb.binding.basis.STD_union):

    """The simple type gml:TimePositionUnion is a union of XML Schema simple types which instantiate the subtypes for temporal position described in ISO 19108.
 An ordinal era may be referenced via URI.  A decimal value may be used to indicate the distance from the scale origin .  time is used for a position that recurs daily (see ISO 19108:2002 5.4.4.2).
 Finally, calendar and clock forms that support the representation of time in systems based on years, months, days, hours, minutes and seconds, in a notation following ISO 8601, are assembled by gml:CalDate"""

    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'TimePositionUnion')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporal.xsd', 204, 1)
    _Documentation = 'The simple type gml:TimePositionUnion is a union of XML Schema simple types which instantiate the subtypes for temporal position described in ISO 19108.\n An ordinal era may be referenced via URI.  A decimal value may be used to indicate the distance from the scale origin .  time is used for a position that recurs daily (see ISO 19108:2002 5.4.4.2).\n Finally, calendar and clock forms that support the representation of time in systems based on years, months, days, hours, minutes and seconds, in a notation following ISO 8601, are assembled by gml:CalDate'

    _MemberTypes = ( pyxb.binding.datatypes.date, pyxb.binding.datatypes.gYearMonth, pyxb.binding.datatypes.gYear, pyxb.binding.datatypes.time, pyxb.binding.datatypes.dateTime, pyxb.binding.datatypes.anyURI, pyxb.binding.datatypes.decimal, )
TimePositionUnion._CF_pattern = pyxb.binding.facets.CF_pattern()
TimePositionUnion._CF_enumeration = pyxb.binding.facets.CF_enumeration(value_datatype=TimePositionUnion)
TimePositionUnion._InitializeFacetMap(TimePositionUnion._CF_pattern,
   TimePositionUnion._CF_enumeration)
_Namespace_gml.addCategoryObject('typeBinding', 'TimePositionUnion', TimePositionUnion)
_module_typeBindings.TimePositionUnion = TimePositionUnion

# Union simple type: {http://www.opengis.net/gml/3.2}CalDate
# superclasses pyxb.binding.datatypes.anySimpleType
class CalDate (pyxb.binding.basis.STD_union):

    """Simple type that is a union of pyxb.binding.datatypes.date, pyxb.binding.datatypes.gYearMonth, pyxb.binding.datatypes.gYear."""

    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'CalDate')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporal.xsd', 212, 1)
    _Documentation = None

    _MemberTypes = ( pyxb.binding.datatypes.date, pyxb.binding.datatypes.gYearMonth, pyxb.binding.datatypes.gYear, )
CalDate._CF_pattern = pyxb.binding.facets.CF_pattern()
CalDate._CF_enumeration = pyxb.binding.facets.CF_enumeration(value_datatype=CalDate)
CalDate._InitializeFacetMap(CalDate._CF_pattern,
   CalDate._CF_enumeration)
_Namespace_gml.addCategoryObject('typeBinding', 'CalDate', CalDate)
_module_typeBindings.CalDate = CalDate

# Atomic simple type: [anonymous]
class STD_ANON_5 (pyxb.binding.datatypes.string, pyxb.binding.basis.enumeration_mixin):

    """An atomic simple type."""

    _ExpandedName = None
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporal.xsd', 252, 3)
    _Documentation = None
STD_ANON_5._CF_enumeration = pyxb.binding.facets.CF_enumeration(value_datatype=STD_ANON_5, enum_prefix=None)
STD_ANON_5.year = STD_ANON_5._CF_enumeration.addEnumeration(unicode_value='year', tag='year')
STD_ANON_5.month = STD_ANON_5._CF_enumeration.addEnumeration(unicode_value='month', tag='month')
STD_ANON_5.day = STD_ANON_5._CF_enumeration.addEnumeration(unicode_value='day', tag='day')
STD_ANON_5.hour = STD_ANON_5._CF_enumeration.addEnumeration(unicode_value='hour', tag='hour')
STD_ANON_5.minute = STD_ANON_5._CF_enumeration.addEnumeration(unicode_value='minute', tag='minute')
STD_ANON_5.second = STD_ANON_5._CF_enumeration.addEnumeration(unicode_value='second', tag='second')
STD_ANON_5._InitializeFacetMap(STD_ANON_5._CF_enumeration)
_module_typeBindings.STD_ANON_5 = STD_ANON_5

# Atomic simple type: [anonymous]
class STD_ANON_6 (pyxb.binding.datatypes.string):

    """An atomic simple type."""

    _ExpandedName = None
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporal.xsd', 262, 3)
    _Documentation = None
STD_ANON_6._CF_pattern = pyxb.binding.facets.CF_pattern()
STD_ANON_6._CF_pattern.addPattern(pattern='other:\\w{2,}')
STD_ANON_6._InitializeFacetMap(STD_ANON_6._CF_pattern)
_module_typeBindings.STD_ANON_6 = STD_ANON_6

# Union simple type: {http://www.opengis.net/gml/3.2}NilReasonType
# superclasses pyxb.binding.datatypes.anySimpleType
class NilReasonType (pyxb.binding.basis.STD_union):

    """gml:NilReasonType defines a content model that allows recording of an explanation for a void value or other exception.
gml:NilReasonType is a union of the following enumerated values:
-	inapplicable there is no value
-	missing the correct value is not readily available to the sender of this data. Furthermore, a correct value may not exist
-	template the value will be available later
-	unknown the correct value is not known to, and not computable by, the sender of this data. However, a correct value probably exists
-	withheld the value is not divulged
-	other:text other brief explanation, where text is a string of two or more characters with no included spaces
and
-	anyURI which should refer to a resource which describes the reason for the exception
A particular community may choose to assign more detailed semantics to the standard values provided. Alternatively, the URI method enables a specific or more complete explanation for the absence of a value to be provided elsewhere and indicated by-reference in an instance document.
gml:NilReasonType is used as a member of a union in a number of simple content types where it is necessary to permit a value from the NilReasonType union as an alternative to the primary type."""

    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'NilReasonType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/basicTypes.xsd', 18, 1)
    _Documentation = 'gml:NilReasonType defines a content model that allows recording of an explanation for a void value or other exception.\ngml:NilReasonType is a union of the following enumerated values:\n-\tinapplicable there is no value\n-\tmissing the correct value is not readily available to the sender of this data. Furthermore, a correct value may not exist\n-\ttemplate the value will be available later\n-\tunknown the correct value is not known to, and not computable by, the sender of this data. However, a correct value probably exists\n-\twithheld the value is not divulged\n-\tother:text other brief explanation, where text is a string of two or more characters with no included spaces\nand\n-\tanyURI which should refer to a resource which describes the reason for the exception\nA particular community may choose to assign more detailed semantics to the standard values provided. Alternatively, the URI method enables a specific or more complete explanation for the absence of a value to be provided elsewhere and indicated by-reference in an instance document.\ngml:NilReasonType is used as a member of a union in a number of simple content types where it is necessary to permit a value from the NilReasonType union as an alternative to the primary type.'

    _MemberTypes = ( STD_ANON, STD_ANON_, pyxb.binding.datatypes.anyURI, )
NilReasonType._CF_pattern = pyxb.binding.facets.CF_pattern()
NilReasonType._CF_enumeration = pyxb.binding.facets.CF_enumeration(value_datatype=NilReasonType)
NilReasonType.inapplicable = 'inapplicable'       # originally STD_ANON.inapplicable
NilReasonType.missing = 'missing'                 # originally STD_ANON.missing
NilReasonType.template = 'template'               # originally STD_ANON.template
NilReasonType.unknown = 'unknown'                 # originally STD_ANON.unknown
NilReasonType.withheld = 'withheld'               # originally STD_ANON.withheld
NilReasonType._InitializeFacetMap(NilReasonType._CF_pattern,
   NilReasonType._CF_enumeration)
_Namespace_gml.addCategoryObject('typeBinding', 'NilReasonType', NilReasonType)
_module_typeBindings.NilReasonType = NilReasonType

# Union simple type: {http://www.opengis.net/gml/3.2}NilReasonEnumeration
# superclasses pyxb.binding.datatypes.anySimpleType
class NilReasonEnumeration (pyxb.binding.basis.STD_union):

    """Simple type that is a union of STD_ANON, STD_ANON_."""

    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'NilReasonEnumeration')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/basicTypes.xsd', 35, 1)
    _Documentation = None

    _MemberTypes = ( STD_ANON, STD_ANON_, )
NilReasonEnumeration._CF_pattern = pyxb.binding.facets.CF_pattern()
NilReasonEnumeration._CF_enumeration = pyxb.binding.facets.CF_enumeration(value_datatype=NilReasonEnumeration)
NilReasonEnumeration.inapplicable = 'inapplicable'# originally STD_ANON.inapplicable
NilReasonEnumeration.missing = 'missing'          # originally STD_ANON.missing
NilReasonEnumeration.template = 'template'        # originally STD_ANON.template
NilReasonEnumeration.unknown = 'unknown'          # originally STD_ANON.unknown
NilReasonEnumeration.withheld = 'withheld'        # originally STD_ANON.withheld
NilReasonEnumeration._InitializeFacetMap(NilReasonEnumeration._CF_pattern,
   NilReasonEnumeration._CF_enumeration)
_Namespace_gml.addCategoryObject('typeBinding', 'NilReasonEnumeration', NilReasonEnumeration)
_module_typeBindings.NilReasonEnumeration = NilReasonEnumeration

# Union simple type: {http://www.opengis.net/gml/3.2}booleanOrNilReason
# superclasses pyxb.binding.datatypes.anySimpleType
class booleanOrNilReason (pyxb.binding.basis.STD_union):

    """Extension to the respective XML Schema built-in simple type to allow a choice of either a value of the built-in simple type or a reason for a nil value."""

    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'booleanOrNilReason')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/basicTypes.xsd', 62, 1)
    _Documentation = 'Extension to the respective XML Schema built-in simple type to allow a choice of either a value of the built-in simple type or a reason for a nil value.'

    _MemberTypes = ( STD_ANON, STD_ANON_, pyxb.binding.datatypes.boolean, pyxb.binding.datatypes.anyURI, )
booleanOrNilReason._CF_pattern = pyxb.binding.facets.CF_pattern()
booleanOrNilReason._CF_enumeration = pyxb.binding.facets.CF_enumeration(value_datatype=booleanOrNilReason)
booleanOrNilReason.inapplicable = 'inapplicable'  # originally STD_ANON.inapplicable
booleanOrNilReason.missing = 'missing'            # originally STD_ANON.missing
booleanOrNilReason.template = 'template'          # originally STD_ANON.template
booleanOrNilReason.unknown = 'unknown'            # originally STD_ANON.unknown
booleanOrNilReason.withheld = 'withheld'          # originally STD_ANON.withheld
booleanOrNilReason._InitializeFacetMap(booleanOrNilReason._CF_pattern,
   booleanOrNilReason._CF_enumeration)
_Namespace_gml.addCategoryObject('typeBinding', 'booleanOrNilReason', booleanOrNilReason)
_module_typeBindings.booleanOrNilReason = booleanOrNilReason

# Union simple type: {http://www.opengis.net/gml/3.2}doubleOrNilReason
# superclasses pyxb.binding.datatypes.anySimpleType
class doubleOrNilReason (pyxb.binding.basis.STD_union):

    """Extension to the respective XML Schema built-in simple type to allow a choice of either a value of the built-in simple type or a reason for a nil value."""

    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'doubleOrNilReason')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/basicTypes.xsd', 68, 1)
    _Documentation = 'Extension to the respective XML Schema built-in simple type to allow a choice of either a value of the built-in simple type or a reason for a nil value.'

    _MemberTypes = ( STD_ANON, STD_ANON_, pyxb.binding.datatypes.double, pyxb.binding.datatypes.anyURI, )
doubleOrNilReason._CF_pattern = pyxb.binding.facets.CF_pattern()
doubleOrNilReason._CF_enumeration = pyxb.binding.facets.CF_enumeration(value_datatype=doubleOrNilReason)
doubleOrNilReason.inapplicable = 'inapplicable'   # originally STD_ANON.inapplicable
doubleOrNilReason.missing = 'missing'             # originally STD_ANON.missing
doubleOrNilReason.template = 'template'           # originally STD_ANON.template
doubleOrNilReason.unknown = 'unknown'             # originally STD_ANON.unknown
doubleOrNilReason.withheld = 'withheld'           # originally STD_ANON.withheld
doubleOrNilReason._InitializeFacetMap(doubleOrNilReason._CF_pattern,
   doubleOrNilReason._CF_enumeration)
_Namespace_gml.addCategoryObject('typeBinding', 'doubleOrNilReason', doubleOrNilReason)
_module_typeBindings.doubleOrNilReason = doubleOrNilReason

# Union simple type: {http://www.opengis.net/gml/3.2}integerOrNilReason
# superclasses pyxb.binding.datatypes.anySimpleType
class integerOrNilReason (pyxb.binding.basis.STD_union):

    """Extension to the respective XML Schema built-in simple type to allow a choice of either a value of the built-in simple type or a reason for a nil value."""

    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'integerOrNilReason')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/basicTypes.xsd', 74, 1)
    _Documentation = 'Extension to the respective XML Schema built-in simple type to allow a choice of either a value of the built-in simple type or a reason for a nil value.'

    _MemberTypes = ( STD_ANON, STD_ANON_, pyxb.binding.datatypes.integer, pyxb.binding.datatypes.anyURI, )
integerOrNilReason._CF_pattern = pyxb.binding.facets.CF_pattern()
integerOrNilReason._CF_enumeration = pyxb.binding.facets.CF_enumeration(value_datatype=integerOrNilReason)
integerOrNilReason.inapplicable = 'inapplicable'  # originally STD_ANON.inapplicable
integerOrNilReason.missing = 'missing'            # originally STD_ANON.missing
integerOrNilReason.template = 'template'          # originally STD_ANON.template
integerOrNilReason.unknown = 'unknown'            # originally STD_ANON.unknown
integerOrNilReason.withheld = 'withheld'          # originally STD_ANON.withheld
integerOrNilReason._InitializeFacetMap(integerOrNilReason._CF_pattern,
   integerOrNilReason._CF_enumeration)
_Namespace_gml.addCategoryObject('typeBinding', 'integerOrNilReason', integerOrNilReason)
_module_typeBindings.integerOrNilReason = integerOrNilReason

# Union simple type: {http://www.opengis.net/gml/3.2}NameOrNilReason
# superclasses pyxb.binding.datatypes.anySimpleType
class NameOrNilReason (pyxb.binding.basis.STD_union):

    """Extension to the respective XML Schema built-in simple type to allow a choice of either a value of the built-in simple type or a reason for a nil value."""

    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'NameOrNilReason')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/basicTypes.xsd', 80, 1)
    _Documentation = 'Extension to the respective XML Schema built-in simple type to allow a choice of either a value of the built-in simple type or a reason for a nil value.'

    _MemberTypes = ( STD_ANON, STD_ANON_, pyxb.binding.datatypes.Name, pyxb.binding.datatypes.anyURI, )
NameOrNilReason._CF_pattern = pyxb.binding.facets.CF_pattern()
NameOrNilReason._CF_enumeration = pyxb.binding.facets.CF_enumeration(value_datatype=NameOrNilReason)
NameOrNilReason.inapplicable = 'inapplicable'     # originally STD_ANON.inapplicable
NameOrNilReason.missing = 'missing'               # originally STD_ANON.missing
NameOrNilReason.template = 'template'             # originally STD_ANON.template
NameOrNilReason.unknown = 'unknown'               # originally STD_ANON.unknown
NameOrNilReason.withheld = 'withheld'             # originally STD_ANON.withheld
NameOrNilReason._InitializeFacetMap(NameOrNilReason._CF_pattern,
   NameOrNilReason._CF_enumeration)
_Namespace_gml.addCategoryObject('typeBinding', 'NameOrNilReason', NameOrNilReason)
_module_typeBindings.NameOrNilReason = NameOrNilReason

# Union simple type: {http://www.opengis.net/gml/3.2}stringOrNilReason
# superclasses pyxb.binding.datatypes.anySimpleType
class stringOrNilReason (pyxb.binding.basis.STD_union):

    """Extension to the respective XML Schema built-in simple type to allow a choice of either a value of the built-in simple type or a reason for a nil value."""

    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'stringOrNilReason')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/basicTypes.xsd', 86, 1)
    _Documentation = 'Extension to the respective XML Schema built-in simple type to allow a choice of either a value of the built-in simple type or a reason for a nil value.'

    _MemberTypes = ( STD_ANON, STD_ANON_, pyxb.binding.datatypes.string, pyxb.binding.datatypes.anyURI, )
stringOrNilReason._CF_pattern = pyxb.binding.facets.CF_pattern()
stringOrNilReason._CF_enumeration = pyxb.binding.facets.CF_enumeration(value_datatype=stringOrNilReason)
stringOrNilReason.inapplicable = 'inapplicable'   # originally STD_ANON.inapplicable
stringOrNilReason.missing = 'missing'             # originally STD_ANON.missing
stringOrNilReason.template = 'template'           # originally STD_ANON.template
stringOrNilReason.unknown = 'unknown'             # originally STD_ANON.unknown
stringOrNilReason.withheld = 'withheld'           # originally STD_ANON.withheld
stringOrNilReason._InitializeFacetMap(stringOrNilReason._CF_pattern,
   stringOrNilReason._CF_enumeration)
_Namespace_gml.addCategoryObject('typeBinding', 'stringOrNilReason', stringOrNilReason)
_module_typeBindings.stringOrNilReason = stringOrNilReason

# Union simple type: {http://www.opengis.net/gml/3.2}UomIdentifier
# superclasses pyxb.binding.datatypes.anySimpleType
class UomIdentifier (pyxb.binding.basis.STD_union):

    """The simple type gml:UomIdentifer defines the syntax and value space of the unit of measure identifier."""

    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'UomIdentifier')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/basicTypes.xsd', 123, 1)
    _Documentation = 'The simple type gml:UomIdentifer defines the syntax and value space of the unit of measure identifier.'

    _MemberTypes = ( UomSymbol, UomURI, )
UomIdentifier._CF_pattern = pyxb.binding.facets.CF_pattern()
UomIdentifier._CF_enumeration = pyxb.binding.facets.CF_enumeration(value_datatype=UomIdentifier)
UomIdentifier._InitializeFacetMap(UomIdentifier._CF_pattern,
   UomIdentifier._CF_enumeration)
_Namespace_gml.addCategoryObject('typeBinding', 'UomIdentifier', UomIdentifier)
_module_typeBindings.UomIdentifier = UomIdentifier

# List simple type: {http://www.opengis.net/gml/3.2}AxisDirectionList
# superclasses pyxb.binding.datatypes.anySimpleType
class AxisDirectionList (pyxb.binding.basis.STD_list):

    """The different values in a gml:AxisDirectionList indicate the incrementation order to be used on all axes of the grid. Each axis shall be mentioned once and only once."""

    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'AxisDirectionList')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coverage.xsd', 222, 1)
    _Documentation = 'The different values in a gml:AxisDirectionList indicate the incrementation order to be used on all axes of the grid. Each axis shall be mentioned once and only once.'

    _ItemType = AxisDirection
AxisDirectionList._InitializeFacetMap()
_Namespace_gml.addCategoryObject('typeBinding', 'AxisDirectionList', AxisDirectionList)
_module_typeBindings.AxisDirectionList = AxisDirectionList

# List simple type: [anonymous]
# superclasses doubleList
class STD_ANON_7 (pyxb.binding.basis.STD_list):

    """Simple type that is a list of pyxb.binding.datatypes.double."""

    _ExpandedName = None
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic0d1d.xsd', 124, 1)
    _Documentation = None

    _ItemType = pyxb.binding.datatypes.double
STD_ANON_7._InitializeFacetMap()
_module_typeBindings.STD_ANON_7 = STD_ANON_7

# Union simple type: {http://www.opengis.net/gml/3.2}TimeUnitType
# superclasses pyxb.binding.datatypes.anySimpleType
class TimeUnitType (pyxb.binding.basis.STD_union):

    """Simple type that is a union of STD_ANON_5, STD_ANON_6."""

    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'TimeUnitType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporal.xsd', 250, 1)
    _Documentation = None

    _MemberTypes = ( STD_ANON_5, STD_ANON_6, )
TimeUnitType._CF_pattern = pyxb.binding.facets.CF_pattern()
TimeUnitType._CF_enumeration = pyxb.binding.facets.CF_enumeration(value_datatype=TimeUnitType)
TimeUnitType.year = 'year'                        # originally STD_ANON_5.year
TimeUnitType.month = 'month'                      # originally STD_ANON_5.month
TimeUnitType.day = 'day'                          # originally STD_ANON_5.day
TimeUnitType.hour = 'hour'                        # originally STD_ANON_5.hour
TimeUnitType.minute = 'minute'                    # originally STD_ANON_5.minute
TimeUnitType.second = 'second'                    # originally STD_ANON_5.second
TimeUnitType._InitializeFacetMap(TimeUnitType._CF_pattern,
   TimeUnitType._CF_enumeration)
_Namespace_gml.addCategoryObject('typeBinding', 'TimeUnitType', TimeUnitType)
_module_typeBindings.TimeUnitType = TimeUnitType

# List simple type: {http://www.opengis.net/gml/3.2}booleanOrNilReasonList
# superclasses pyxb.binding.datatypes.anySimpleType
class booleanOrNilReasonList (pyxb.binding.basis.STD_list):

    """A type for a list of values of the respective simple type."""

    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'booleanOrNilReasonList')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/basicTypes.xsd', 204, 1)
    _Documentation = 'A type for a list of values of the respective simple type.'

    _ItemType = booleanOrNilReason
booleanOrNilReasonList._InitializeFacetMap()
_Namespace_gml.addCategoryObject('typeBinding', 'booleanOrNilReasonList', booleanOrNilReasonList)
_module_typeBindings.booleanOrNilReasonList = booleanOrNilReasonList

# List simple type: {http://www.opengis.net/gml/3.2}NameOrNilReasonList
# superclasses pyxb.binding.datatypes.anySimpleType
class NameOrNilReasonList (pyxb.binding.basis.STD_list):

    """A type for a list of values of the respective simple type."""

    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'NameOrNilReasonList')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/basicTypes.xsd', 210, 1)
    _Documentation = 'A type for a list of values of the respective simple type.'

    _ItemType = NameOrNilReason
NameOrNilReasonList._InitializeFacetMap()
_Namespace_gml.addCategoryObject('typeBinding', 'NameOrNilReasonList', NameOrNilReasonList)
_module_typeBindings.NameOrNilReasonList = NameOrNilReasonList

# List simple type: {http://www.opengis.net/gml/3.2}doubleOrNilReasonList
# superclasses pyxb.binding.datatypes.anySimpleType
class doubleOrNilReasonList (pyxb.binding.basis.STD_list):

    """A type for a list of values of the respective simple type."""

    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'doubleOrNilReasonList')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/basicTypes.xsd', 216, 1)
    _Documentation = 'A type for a list of values of the respective simple type.'

    _ItemType = doubleOrNilReason
doubleOrNilReasonList._InitializeFacetMap()
_Namespace_gml.addCategoryObject('typeBinding', 'doubleOrNilReasonList', doubleOrNilReasonList)
_module_typeBindings.doubleOrNilReasonList = doubleOrNilReasonList

# List simple type: {http://www.opengis.net/gml/3.2}integerOrNilReasonList
# superclasses pyxb.binding.datatypes.anySimpleType
class integerOrNilReasonList (pyxb.binding.basis.STD_list):

    """A type for a list of values of the respective simple type."""

    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'integerOrNilReasonList')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/basicTypes.xsd', 222, 1)
    _Documentation = 'A type for a list of values of the respective simple type.'

    _ItemType = integerOrNilReason
integerOrNilReasonList._InitializeFacetMap()
_Namespace_gml.addCategoryObject('typeBinding', 'integerOrNilReasonList', integerOrNilReasonList)
_module_typeBindings.integerOrNilReasonList = integerOrNilReasonList

# List simple type: [anonymous]
# superclasses NameOrNilReasonList
class STD_ANON_8 (pyxb.binding.basis.STD_list):

    """Simple type that is a list of NameOrNilReason."""

    _ExpandedName = None
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/valueObjects.xsd', 160, 1)
    _Documentation = None

    _ItemType = NameOrNilReason
STD_ANON_8._CF_length = pyxb.binding.facets.CF_length(value=pyxb.binding.datatypes.nonNegativeInteger(2))
STD_ANON_8._InitializeFacetMap(STD_ANON_8._CF_length)
_module_typeBindings.STD_ANON_8 = STD_ANON_8

# List simple type: {http://www.opengis.net/gml/3.2}CountExtentType
# superclasses integerOrNilReasonList
class CountExtentType (pyxb.binding.basis.STD_list):

    """Simple type that is a list of integerOrNilReason."""

    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'CountExtentType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/valueObjects.xsd', 168, 1)
    _Documentation = None

    _ItemType = integerOrNilReason
CountExtentType._CF_length = pyxb.binding.facets.CF_length(value=pyxb.binding.datatypes.nonNegativeInteger(2))
CountExtentType._InitializeFacetMap(CountExtentType._CF_length)
_Namespace_gml.addCategoryObject('typeBinding', 'CountExtentType', CountExtentType)
_module_typeBindings.CountExtentType = CountExtentType

# List simple type: [anonymous]
# superclasses doubleOrNilReasonList
class STD_ANON_9 (pyxb.binding.basis.STD_list):

    """Simple type that is a list of doubleOrNilReason."""

    _ExpandedName = None
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/valueObjects.xsd', 174, 1)
    _Documentation = None

    _ItemType = doubleOrNilReason
STD_ANON_9._CF_length = pyxb.binding.facets.CF_length(value=pyxb.binding.datatypes.nonNegativeInteger(2))
STD_ANON_9._InitializeFacetMap(STD_ANON_9._CF_length)
_module_typeBindings.STD_ANON_9 = STD_ANON_9

# Complex type {http://www.isotc211.org/2005/gco}UnlimitedInteger_Type with content type SIMPLE
class UnlimitedInteger_Type (pyxb.binding.basis.complexTypeDefinition):
    """Complex type {http://www.isotc211.org/2005/gco}UnlimitedInteger_Type with content type SIMPLE"""
    _TypeDefinition = pyxb.binding.datatypes.nonNegativeInteger
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_SIMPLE
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gco, 'UnlimitedInteger_Type')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 362, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.nonNegativeInteger
    
    # Attribute isInfinite uses Python identifier isInfinite
    __isInfinite = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'isInfinite'), 'isInfinite', '__httpwww_isotc211_org2005gco_UnlimitedInteger_Type_isInfinite', pyxb.binding.datatypes.boolean)
    __isInfinite._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 365, 4)
    __isInfinite._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 365, 4)
    
    isInfinite = property(__isInfinite.value, __isInfinite.set, None, None)

    _ElementMap.update({
        
    })
    _AttributeMap.update({
        __isInfinite.name() : __isInfinite
    })
_module_typeBindings.UnlimitedInteger_Type = UnlimitedInteger_Type
_Namespace_gco.addCategoryObject('typeBinding', 'UnlimitedInteger_Type', UnlimitedInteger_Type)


# Complex type {http://www.isotc211.org/2005/gco}Binary_Type with content type SIMPLE
class Binary_Type (pyxb.binding.basis.complexTypeDefinition):
    """Complex type {http://www.isotc211.org/2005/gco}Binary_Type with content type SIMPLE"""
    _TypeDefinition = pyxb.binding.datatypes.string
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_SIMPLE
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gco, 'Binary_Type')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 412, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.string
    
    # Attribute src uses Python identifier src
    __src = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'src'), 'src', '__httpwww_isotc211_org2005gco_Binary_Type_src', pyxb.binding.datatypes.anyURI)
    __src._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 415, 4)
    __src._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 415, 4)
    
    src = property(__src.value, __src.set, None, None)

    _ElementMap.update({
        
    })
    _AttributeMap.update({
        __src.name() : __src
    })
_module_typeBindings.Binary_Type = Binary_Type
_Namespace_gco.addCategoryObject('typeBinding', 'Binary_Type', Binary_Type)


# Complex type {http://www.isotc211.org/2005/gco}AbstractObject_Type with content type EMPTY
class AbstractObject_Type (pyxb.binding.basis.complexTypeDefinition):
    """Complex type {http://www.isotc211.org/2005/gco}AbstractObject_Type with content type EMPTY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_EMPTY
    _Abstract = True
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gco, 'AbstractObject_Type')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 19, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Attribute id uses Python identifier id
    __id = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'id'), 'id', '__httpwww_isotc211_org2005gco_AbstractObject_Type_id', pyxb.binding.datatypes.ID)
    __id._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 43, 2)
    __id._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 43, 2)
    
    id = property(__id.value, __id.set, None, None)

    
    # Attribute uuid uses Python identifier uuid
    __uuid = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'uuid'), 'uuid', '__httpwww_isotc211_org2005gco_AbstractObject_Type_uuid', pyxb.binding.datatypes.string)
    __uuid._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 44, 2)
    __uuid._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 44, 2)
    
    uuid = property(__uuid.value, __uuid.set, None, None)

    _ElementMap.update({
        
    })
    _AttributeMap.update({
        __id.name() : __id,
        __uuid.name() : __uuid
    })
_module_typeBindings.AbstractObject_Type = AbstractObject_Type
_Namespace_gco.addCategoryObject('typeBinding', 'AbstractObject_Type', AbstractObject_Type)


# Complex type {http://www.isotc211.org/2005/gco}CodeListValue_Type with content type SIMPLE
class CodeListValue_Type (pyxb.binding.basis.complexTypeDefinition):
    """Complex type {http://www.isotc211.org/2005/gco}CodeListValue_Type with content type SIMPLE"""
    _TypeDefinition = pyxb.binding.datatypes.string
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_SIMPLE
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gco, 'CodeListValue_Type')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 50, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.string
    
    # Attribute codeList uses Python identifier codeList
    __codeList = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'codeList'), 'codeList', '__httpwww_isotc211_org2005gco_CodeListValue_Type_codeList', pyxb.binding.datatypes.anyURI, required=True)
    __codeList._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 53, 4)
    __codeList._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 53, 4)
    
    codeList = property(__codeList.value, __codeList.set, None, None)

    
    # Attribute codeListValue uses Python identifier codeListValue
    __codeListValue = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'codeListValue'), 'codeListValue', '__httpwww_isotc211_org2005gco_CodeListValue_Type_codeListValue', pyxb.binding.datatypes.anyURI, required=True)
    __codeListValue._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 54, 4)
    __codeListValue._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 54, 4)
    
    codeListValue = property(__codeListValue.value, __codeListValue.set, None, None)

    
    # Attribute codeSpace uses Python identifier codeSpace
    __codeSpace = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'codeSpace'), 'codeSpace', '__httpwww_isotc211_org2005gco_CodeListValue_Type_codeSpace', pyxb.binding.datatypes.anyURI)
    __codeSpace._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 55, 4)
    __codeSpace._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 55, 4)
    
    codeSpace = property(__codeSpace.value, __codeSpace.set, None, None)

    _ElementMap.update({
        
    })
    _AttributeMap.update({
        __codeList.name() : __codeList,
        __codeListValue.name() : __codeListValue,
        __codeSpace.name() : __codeSpace
    })
_module_typeBindings.CodeListValue_Type = CodeListValue_Type
_Namespace_gco.addCategoryObject('typeBinding', 'CodeListValue_Type', CodeListValue_Type)


# Complex type {http://www.isotc211.org/2005/gmd}LocalisedCharacterString_Type with content type SIMPLE
class LocalisedCharacterString_Type (pyxb.binding.basis.complexTypeDefinition):
    """Complex type {http://www.isotc211.org/2005/gmd}LocalisedCharacterString_Type with content type SIMPLE"""
    _TypeDefinition = pyxb.binding.datatypes.string
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_SIMPLE
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'LocalisedCharacterString_Type')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/freeText.xsd', 58, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.string
    
    # Attribute id uses Python identifier id
    __id = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'id'), 'id', '__httpwww_isotc211_org2005gmd_LocalisedCharacterString_Type_id', pyxb.binding.datatypes.ID)
    __id._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/freeText.xsd', 61, 4)
    __id._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/freeText.xsd', 61, 4)
    
    id = property(__id.value, __id.set, None, None)

    
    # Attribute locale uses Python identifier locale
    __locale = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'locale'), 'locale', '__httpwww_isotc211_org2005gmd_LocalisedCharacterString_Type_locale', pyxb.binding.datatypes.anyURI)
    __locale._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/freeText.xsd', 62, 4)
    __locale._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/freeText.xsd', 62, 4)
    
    locale = property(__locale.value, __locale.set, None, None)

    _ElementMap.update({
        
    })
    _AttributeMap.update({
        __id.name() : __id,
        __locale.name() : __locale
    })
_module_typeBindings.LocalisedCharacterString_Type = LocalisedCharacterString_Type
_Namespace_gmd.addCategoryObject('typeBinding', 'LocalisedCharacterString_Type', LocalisedCharacterString_Type)


# Complex type {http://www.isotc211.org/2005/gmd}PT_LocaleContainer_Type with content type ELEMENT_ONLY
class PT_LocaleContainer_Type (pyxb.binding.basis.complexTypeDefinition):
    """Complex type {http://www.isotc211.org/2005/gmd}PT_LocaleContainer_Type with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'PT_LocaleContainer_Type')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/freeText.xsd', 79, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.isotc211.org/2005/gmd}description uses Python identifier description
    __description = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'description'), 'description', '__httpwww_isotc211_org2005gmd_PT_LocaleContainer_Type_httpwww_isotc211_org2005gmddescription', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/freeText.xsd', 81, 3), )

    
    description = property(__description.value, __description.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}locale uses Python identifier locale
    __locale = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'locale'), 'locale', '__httpwww_isotc211_org2005gmd_PT_LocaleContainer_Type_httpwww_isotc211_org2005gmdlocale', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/freeText.xsd', 82, 3), )

    
    locale = property(__locale.value, __locale.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}date uses Python identifier date
    __date = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'date'), 'date', '__httpwww_isotc211_org2005gmd_PT_LocaleContainer_Type_httpwww_isotc211_org2005gmddate', True, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/freeText.xsd', 83, 3), )

    
    date = property(__date.value, __date.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}responsibleParty uses Python identifier responsibleParty
    __responsibleParty = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'responsibleParty'), 'responsibleParty', '__httpwww_isotc211_org2005gmd_PT_LocaleContainer_Type_httpwww_isotc211_org2005gmdresponsibleParty', True, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/freeText.xsd', 84, 3), )

    
    responsibleParty = property(__responsibleParty.value, __responsibleParty.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}localisedString uses Python identifier localisedString
    __localisedString = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'localisedString'), 'localisedString', '__httpwww_isotc211_org2005gmd_PT_LocaleContainer_Type_httpwww_isotc211_org2005gmdlocalisedString', True, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/freeText.xsd', 85, 3), )

    
    localisedString = property(__localisedString.value, __localisedString.set, None, None)

    _ElementMap.update({
        __description.name() : __description,
        __locale.name() : __locale,
        __date.name() : __date,
        __responsibleParty.name() : __responsibleParty,
        __localisedString.name() : __localisedString
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.PT_LocaleContainer_Type = PT_LocaleContainer_Type
_Namespace_gmd.addCategoryObject('typeBinding', 'PT_LocaleContainer_Type', PT_LocaleContainer_Type)


# Complex type {http://www.isotc211.org/2005/gmd}MD_Resolution_Type with content type ELEMENT_ONLY
class MD_Resolution_Type (pyxb.binding.basis.complexTypeDefinition):
    """Complex type {http://www.isotc211.org/2005/gmd}MD_Resolution_Type with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_Resolution_Type')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 237, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.isotc211.org/2005/gmd}equivalentScale uses Python identifier equivalentScale
    __equivalentScale = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'equivalentScale'), 'equivalentScale', '__httpwww_isotc211_org2005gmd_MD_Resolution_Type_httpwww_isotc211_org2005gmdequivalentScale', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 239, 3), )

    
    equivalentScale = property(__equivalentScale.value, __equivalentScale.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}distance uses Python identifier distance
    __distance = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'distance'), 'distance', '__httpwww_isotc211_org2005gmd_MD_Resolution_Type_httpwww_isotc211_org2005gmddistance', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 240, 3), )

    
    distance = property(__distance.value, __distance.set, None, None)

    _ElementMap.update({
        __equivalentScale.name() : __equivalentScale,
        __distance.name() : __distance
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.MD_Resolution_Type = MD_Resolution_Type
_Namespace_gmd.addCategoryObject('typeBinding', 'MD_Resolution_Type', MD_Resolution_Type)


# Complex type {http://www.isotc211.org/2005/gmd}MD_ScopeDescription_Type with content type ELEMENT_ONLY
class MD_ScopeDescription_Type (pyxb.binding.basis.complexTypeDefinition):
    """Description of the class of information covered by the information"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_ScopeDescription_Type')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/maintenance.xsd', 44, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.isotc211.org/2005/gmd}attributes uses Python identifier attributes
    __attributes = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'attributes'), 'attributes', '__httpwww_isotc211_org2005gmd_MD_ScopeDescription_Type_httpwww_isotc211_org2005gmdattributes', True, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/maintenance.xsd', 49, 3), )

    
    attributes = property(__attributes.value, __attributes.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}features uses Python identifier features
    __features = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'features'), 'features', '__httpwww_isotc211_org2005gmd_MD_ScopeDescription_Type_httpwww_isotc211_org2005gmdfeatures', True, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/maintenance.xsd', 50, 3), )

    
    features = property(__features.value, __features.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}featureInstances uses Python identifier featureInstances
    __featureInstances = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'featureInstances'), 'featureInstances', '__httpwww_isotc211_org2005gmd_MD_ScopeDescription_Type_httpwww_isotc211_org2005gmdfeatureInstances', True, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/maintenance.xsd', 51, 3), )

    
    featureInstances = property(__featureInstances.value, __featureInstances.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}attributeInstances uses Python identifier attributeInstances
    __attributeInstances = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'attributeInstances'), 'attributeInstances', '__httpwww_isotc211_org2005gmd_MD_ScopeDescription_Type_httpwww_isotc211_org2005gmdattributeInstances', True, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/maintenance.xsd', 52, 3), )

    
    attributeInstances = property(__attributeInstances.value, __attributeInstances.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}dataset uses Python identifier dataset
    __dataset = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'dataset'), 'dataset', '__httpwww_isotc211_org2005gmd_MD_ScopeDescription_Type_httpwww_isotc211_org2005gmddataset', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/maintenance.xsd', 53, 3), )

    
    dataset = property(__dataset.value, __dataset.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}other uses Python identifier other
    __other = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'other'), 'other', '__httpwww_isotc211_org2005gmd_MD_ScopeDescription_Type_httpwww_isotc211_org2005gmdother', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/maintenance.xsd', 54, 3), )

    
    other = property(__other.value, __other.set, None, None)

    _ElementMap.update({
        __attributes.name() : __attributes,
        __features.name() : __features,
        __featureInstances.name() : __featureInstances,
        __attributeInstances.name() : __attributeInstances,
        __dataset.name() : __dataset,
        __other.name() : __other
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.MD_ScopeDescription_Type = MD_ScopeDescription_Type
_Namespace_gmd.addCategoryObject('typeBinding', 'MD_ScopeDescription_Type', MD_ScopeDescription_Type)


# Complex type {http://www.opengis.net/gml/3.2}CodeType with content type SIMPLE
class CodeType (pyxb.binding.basis.complexTypeDefinition):
    """gml:CodeType is a generalized type to be used for a term, keyword or name.
It adds a XML attribute codeSpace to a term, where the value of the codeSpace attribute (if present) shall indicate a dictionary, thesaurus, classification scheme, authority, or pattern for the term."""
    _TypeDefinition = pyxb.binding.datatypes.string
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_SIMPLE
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'CodeType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/basicTypes.xsd', 92, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.string
    
    # Attribute codeSpace uses Python identifier codeSpace
    __codeSpace = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'codeSpace'), 'codeSpace', '__httpwww_opengis_netgml3_2_CodeType_codeSpace', pyxb.binding.datatypes.anyURI)
    __codeSpace._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/basicTypes.xsd', 99, 4)
    __codeSpace._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/basicTypes.xsd', 99, 4)
    
    codeSpace = property(__codeSpace.value, __codeSpace.set, None, None)

    _ElementMap.update({
        
    })
    _AttributeMap.update({
        __codeSpace.name() : __codeSpace
    })
_module_typeBindings.CodeType = CodeType
_Namespace_gml.addCategoryObject('typeBinding', 'CodeType', CodeType)


# Complex type {http://www.opengis.net/gml/3.2}CoordinatesType with content type SIMPLE
class CoordinatesType (pyxb.binding.basis.complexTypeDefinition):
    """This type is deprecated for tuples with ordinate values that are numbers.
CoordinatesType is a text string, intended to be used to record an array of tuples or coordinates. 
While it is not possible to enforce the internal structure of the string through schema validation, some optional attributes have been provided in previous versions of GML to support a description of the internal structure. These attributes are deprecated. The attributes were intended to be used as follows:
Decimal	symbol used for a decimal point (default="." a stop or period)
cs        	symbol used to separate components within a tuple or coordinate string (default="," a comma)
ts        	symbol used to separate tuples or coordinate strings (default=" " a space)
Since it is based on the XML Schema string type, CoordinatesType may be used in the construction of tables of tuples or arrays of tuples, including ones that contain mixed text and numeric values."""
    _TypeDefinition = pyxb.binding.datatypes.string
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_SIMPLE
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'CoordinatesType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/basicTypes.xsd', 150, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.string
    
    # Attribute decimal uses Python identifier decimal
    __decimal = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'decimal'), 'decimal', '__httpwww_opengis_netgml3_2_CoordinatesType_decimal', pyxb.binding.datatypes.string, unicode_default='.')
    __decimal._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/basicTypes.xsd', 162, 4)
    __decimal._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/basicTypes.xsd', 162, 4)
    
    decimal = property(__decimal.value, __decimal.set, None, None)

    
    # Attribute cs uses Python identifier cs
    __cs = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'cs'), 'cs', '__httpwww_opengis_netgml3_2_CoordinatesType_cs', pyxb.binding.datatypes.string, unicode_default=',')
    __cs._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/basicTypes.xsd', 163, 4)
    __cs._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/basicTypes.xsd', 163, 4)
    
    cs = property(__cs.value, __cs.set, None, None)

    
    # Attribute ts uses Python identifier ts
    __ts = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'ts'), 'ts', '__httpwww_opengis_netgml3_2_CoordinatesType_ts', pyxb.binding.datatypes.string, unicode_default=' ')
    __ts._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/basicTypes.xsd', 164, 4)
    __ts._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/basicTypes.xsd', 164, 4)
    
    ts = property(__ts.value, __ts.set, None, None)

    _ElementMap.update({
        
    })
    _AttributeMap.update({
        __decimal.name() : __decimal,
        __cs.name() : __cs,
        __ts.name() : __ts
    })
_module_typeBindings.CoordinatesType = CoordinatesType
_Namespace_gml.addCategoryObject('typeBinding', 'CoordinatesType', CoordinatesType)


# Complex type {http://www.opengis.net/gml/3.2}AbstractGeneralParameterValueType with content type EMPTY
class AbstractGeneralParameterValueType (pyxb.binding.basis.complexTypeDefinition):
    """Complex type {http://www.opengis.net/gml/3.2}AbstractGeneralParameterValueType with content type EMPTY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_EMPTY
    _Abstract = True
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractGeneralParameterValueType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 289, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    _ElementMap.update({
        
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.AbstractGeneralParameterValueType = AbstractGeneralParameterValueType
_Namespace_gml.addCategoryObject('typeBinding', 'AbstractGeneralParameterValueType', AbstractGeneralParameterValueType)


# Complex type {http://www.opengis.net/gml/3.2}AbstractGeneralParameterValuePropertyType with content type ELEMENT_ONLY
class AbstractGeneralParameterValuePropertyType (pyxb.binding.basis.complexTypeDefinition):
    """gml:AbstractGeneralParameterValuePropertyType is a  property type for inline association roles to a parameter value or group of parameter values, always containing the values."""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractGeneralParameterValuePropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 292, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.opengis.net/gml/3.2}AbstractGeneralParameterValue uses Python identifier AbstractGeneralParameterValue
    __AbstractGeneralParameterValue = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractGeneralParameterValue'), 'AbstractGeneralParameterValue', '__httpwww_opengis_netgml3_2_AbstractGeneralParameterValuePropertyType_httpwww_opengis_netgml3_2AbstractGeneralParameterValue', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 283, 1), )

    
    AbstractGeneralParameterValue = property(__AbstractGeneralParameterValue.value, __AbstractGeneralParameterValue.set, None, 'gml:AbstractGeneralParameterValue is an abstract parameter value or group of parameter values.\nThis abstract complexType is expected to be extended and restricted for well-known operation methods with many instances, in Application Schemas that define operation-method-specialized element names and contents. Specific parameter value elements are directly contained in concrete subtypes, not in this abstract type. All concrete types derived from this type shall extend this type to include one "...Value" element with an appropriate type, which should be one of the element types allowed in the ParameterValueType. In addition, all derived concrete types shall extend this type to include a "operationParameter" property element that references one element substitutable for the "OperationParameter" object element.')

    _ElementMap.update({
        __AbstractGeneralParameterValue.name() : __AbstractGeneralParameterValue
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.AbstractGeneralParameterValuePropertyType = AbstractGeneralParameterValuePropertyType
_Namespace_gml.addCategoryObject('typeBinding', 'AbstractGeneralParameterValuePropertyType', AbstractGeneralParameterValuePropertyType)


# Complex type {http://www.opengis.net/gml/3.2}RangeSetType with content type ELEMENT_ONLY
class RangeSetType (pyxb.binding.basis.complexTypeDefinition):
    """Complex type {http://www.opengis.net/gml/3.2}RangeSetType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'RangeSetType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coverage.xsd', 95, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.opengis.net/gml/3.2}DataBlock uses Python identifier DataBlock
    __DataBlock = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'DataBlock'), 'DataBlock', '__httpwww_opengis_netgml3_2_RangeSetType_httpwww_opengis_netgml3_2DataBlock', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coverage.xsd', 103, 1), )

    
    DataBlock = property(__DataBlock.value, __DataBlock.set, None, 'gml:DataBlock describes the Range as a block of text encoded values similar to a Common Separated Value (CSV) representation.\nThe range set parameterization is described by the property gml:rangeParameters.')

    
    # Element {http://www.opengis.net/gml/3.2}File uses Python identifier File
    __File = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'File'), 'File', '__httpwww_opengis_netgml3_2_RangeSetType_httpwww_opengis_netgml3_2File', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coverage.xsd', 130, 1), )

    
    File = property(__File.value, __File.set, None, 'for efficiency reasons, GML also provides a means of encoding the range set in an arbitrary external encoding, such as a binary file.  This encoding may be "well-known" but this is not required. This mode uses the gml:File element.\nThe values of the coverage (attribute values in the range set) are transmitted in a external file that is referenced from the XML structure described by gml:FileType.  The external file is referenced by the gml:fileReference property that is an anyURI (the gml:fileName property has been deprecated).  This means that the external file may be located remotely from the referencing GML instance. \nThe gml:compression property points to a definition of a compression algorithm through an anyURI.  This may be a retrievable, computable definition or simply a reference to an unambiguous name for the compression method.\nThe gml:mimeType property points to a definition of the file mime type.\nThe gml:fileStructure property is defined by a codelist. Note further that all values shall be enclosed in a single file. Multi-file structures for values are not supported in GML.\nThe semantics of the range set is described as above using the gml:rangeParameters property.\nNote that if any compression algorithm is applied, the structure above applies only to the pre-compression or post-decompression structure of the file.\nNote that the fields within a record match the gml:valueComponents of the gml:CompositeValue in document order.')

    
    # Element {http://www.opengis.net/gml/3.2}AbstractScalarValueList uses Python identifier AbstractScalarValueList
    __AbstractScalarValueList = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractScalarValueList'), 'AbstractScalarValueList', '__httpwww_opengis_netgml3_2_RangeSetType_httpwww_opengis_netgml3_2AbstractScalarValueList', True, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/valueObjects.xsd', 81, 1), )

    
    AbstractScalarValueList = property(__AbstractScalarValueList.value, __AbstractScalarValueList.set, None, 'gml:AbstractScalarValueList is an abstract element which acts as the head of a substitution group which contains gml:BooleanList, gml:CategoryList, gml:CountList and gml:QuantityList, and (transitively) the elements in their substitution groups.')

    
    # Element {http://www.opengis.net/gml/3.2}ValueArray uses Python identifier ValueArray
    __ValueArray = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'ValueArray'), 'ValueArray', '__httpwww_opengis_netgml3_2_RangeSetType_httpwww_opengis_netgml3_2ValueArray', True, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/valueObjects.xsd', 141, 1), )

    
    ValueArray = property(__ValueArray.value, __ValueArray.set, None, 'A Value Array is used for homogeneous arrays of primitive and aggregate values.  \nThe member values may be scalars, composites, arrays or lists.\nValueArray has the same content model as CompositeValue, but the member values shall be homogeneous.  The element declaration contains a Schematron constraint which expresses this restriction precisely.  Since the members are homogeneous, the gml:referenceSystem (uom, codeSpace) may be specified on the gml:ValueArray itself and inherited by all the members if desired.')

    _ElementMap.update({
        __DataBlock.name() : __DataBlock,
        __File.name() : __File,
        __AbstractScalarValueList.name() : __AbstractScalarValueList,
        __ValueArray.name() : __ValueArray
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.RangeSetType = RangeSetType
_Namespace_gml.addCategoryObject('typeBinding', 'RangeSetType', RangeSetType)


# Complex type {http://www.opengis.net/gml/3.2}DataBlockType with content type ELEMENT_ONLY
class DataBlockType (pyxb.binding.basis.complexTypeDefinition):
    """Complex type {http://www.opengis.net/gml/3.2}DataBlockType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'DataBlockType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coverage.xsd', 109, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.opengis.net/gml/3.2}rangeParameters uses Python identifier rangeParameters
    __rangeParameters = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'rangeParameters'), 'rangeParameters', '__httpwww_opengis_netgml3_2_DataBlockType_httpwww_opengis_netgml3_2rangeParameters', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coverage.xsd', 118, 1), )

    
    rangeParameters = property(__rangeParameters.value, __rangeParameters.set, None, None)

    
    # Element {http://www.opengis.net/gml/3.2}tupleList uses Python identifier tupleList
    __tupleList = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'tupleList'), 'tupleList', '__httpwww_opengis_netgml3_2_DataBlockType_httpwww_opengis_netgml3_2tupleList', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coverage.xsd', 119, 1), )

    
    tupleList = property(__tupleList.value, __tupleList.set, None, 'gml:CoordinatesType consists of a list of coordinate tuples, with each coordinate tuple separated by the ts or tuple separator (whitespace), and each coordinate in the tuple by the cs or coordinate separator (comma).\nThe gml:tupleList encoding is effectively "band-interleaved".')

    
    # Element {http://www.opengis.net/gml/3.2}doubleOrNilReasonTupleList uses Python identifier doubleOrNilReasonTupleList
    __doubleOrNilReasonTupleList = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'doubleOrNilReasonTupleList'), 'doubleOrNilReasonTupleList', '__httpwww_opengis_netgml3_2_DataBlockType_httpwww_opengis_netgml3_2doubleOrNilReasonTupleList', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coverage.xsd', 125, 1), )

    
    doubleOrNilReasonTupleList = property(__doubleOrNilReasonTupleList.value, __doubleOrNilReasonTupleList.set, None, 'gml:doubleOrNilReasonList consists of a list of gml:doubleOrNilReason values, each separated by a whitespace. The gml:doubleOrNilReason values are grouped into tuples where the dimension of each tuple in the list is equal to the number of range parameters.')

    _ElementMap.update({
        __rangeParameters.name() : __rangeParameters,
        __tupleList.name() : __tupleList,
        __doubleOrNilReasonTupleList.name() : __doubleOrNilReasonTupleList
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.DataBlockType = DataBlockType
_Namespace_gml.addCategoryObject('typeBinding', 'DataBlockType', DataBlockType)


# Complex type {http://www.opengis.net/gml/3.2}FileType with content type ELEMENT_ONLY
class FileType (pyxb.binding.basis.complexTypeDefinition):
    """Complex type {http://www.opengis.net/gml/3.2}FileType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'FileType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coverage.xsd', 142, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.opengis.net/gml/3.2}rangeParameters uses Python identifier rangeParameters
    __rangeParameters = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'rangeParameters'), 'rangeParameters', '__httpwww_opengis_netgml3_2_FileType_httpwww_opengis_netgml3_2rangeParameters', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coverage.xsd', 118, 1), )

    
    rangeParameters = property(__rangeParameters.value, __rangeParameters.set, None, None)

    
    # Element {http://www.opengis.net/gml/3.2}fileName uses Python identifier fileName
    __fileName = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'fileName'), 'fileName', '__httpwww_opengis_netgml3_2_FileType_httpwww_opengis_netgml3_2fileName', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coverage.xsd', 146, 4), )

    
    fileName = property(__fileName.value, __fileName.set, None, '')

    
    # Element {http://www.opengis.net/gml/3.2}fileReference uses Python identifier fileReference
    __fileReference = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'fileReference'), 'fileReference', '__httpwww_opengis_netgml3_2_FileType_httpwww_opengis_netgml3_2fileReference', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coverage.xsd', 151, 4), )

    
    fileReference = property(__fileReference.value, __fileReference.set, None, None)

    
    # Element {http://www.opengis.net/gml/3.2}fileStructure uses Python identifier fileStructure
    __fileStructure = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'fileStructure'), 'fileStructure', '__httpwww_opengis_netgml3_2_FileType_httpwww_opengis_netgml3_2fileStructure', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coverage.xsd', 153, 3), )

    
    fileStructure = property(__fileStructure.value, __fileStructure.set, None, None)

    
    # Element {http://www.opengis.net/gml/3.2}mimeType uses Python identifier mimeType
    __mimeType = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'mimeType'), 'mimeType', '__httpwww_opengis_netgml3_2_FileType_httpwww_opengis_netgml3_2mimeType', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coverage.xsd', 154, 3), )

    
    mimeType = property(__mimeType.value, __mimeType.set, None, None)

    
    # Element {http://www.opengis.net/gml/3.2}compression uses Python identifier compression
    __compression = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'compression'), 'compression', '__httpwww_opengis_netgml3_2_FileType_httpwww_opengis_netgml3_2compression', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coverage.xsd', 155, 3), )

    
    compression = property(__compression.value, __compression.set, None, None)

    _ElementMap.update({
        __rangeParameters.name() : __rangeParameters,
        __fileName.name() : __fileName,
        __fileReference.name() : __fileReference,
        __fileStructure.name() : __fileStructure,
        __mimeType.name() : __mimeType,
        __compression.name() : __compression
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.FileType = FileType
_Namespace_gml.addCategoryObject('typeBinding', 'FileType', FileType)


# Complex type {http://www.opengis.net/gml/3.2}CoverageFunctionType with content type ELEMENT_ONLY
class CoverageFunctionType (pyxb.binding.basis.complexTypeDefinition):
    """Complex type {http://www.opengis.net/gml/3.2}CoverageFunctionType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'CoverageFunctionType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coverage.xsd', 165, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.opengis.net/gml/3.2}CoverageMappingRule uses Python identifier CoverageMappingRule
    __CoverageMappingRule = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'CoverageMappingRule'), 'CoverageMappingRule', '__httpwww_opengis_netgml3_2_CoverageFunctionType_httpwww_opengis_netgml3_2CoverageMappingRule', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coverage.xsd', 172, 1), )

    
    CoverageMappingRule = property(__CoverageMappingRule.value, __CoverageMappingRule.set, None, "gml:CoverageMappingRule provides a formal or informal description of the coverage function.\nThe mapping rule may be defined as an in-line string (gml:ruleDefinition) or via a remote reference through xlink:href (gml:ruleReference).  \nIf no rule name is specified, the default is 'Linear' with respect to members of the domain in document order.")

    
    # Element {http://www.opengis.net/gml/3.2}GridFunction uses Python identifier GridFunction
    __GridFunction = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'GridFunction'), 'GridFunction', '__httpwww_opengis_netgml3_2_CoverageFunctionType_httpwww_opengis_netgml3_2GridFunction', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coverage.xsd', 185, 1), )

    
    GridFunction = property(__GridFunction.value, __GridFunction.set, None, 'gml:GridFunction provides an explicit mapping rule for grid geometries, i.e. the domain shall be a geometry of type grid.  It describes the mapping of grid posts (discrete point grid coverage) or grid cells (discrete surface coverage) to the values in the range set.\nThe gml:startPoint is the index position of a point in the grid that is mapped to the first point in the range set (this is also the index position of the first grid post).  If the gml:startPoint property is omitted the gml:startPoint is assumed to be equal to the value of gml:low in the gml:Grid geometry. Subsequent points in the mapping are determined by the value of the gml:sequenceRule.')

    
    # Element {http://www.opengis.net/gml/3.2}MappingRule uses Python identifier MappingRule
    __MappingRule = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'MappingRule'), 'MappingRule', '__httpwww_opengis_netgml3_2_CoverageFunctionType_httpwww_opengis_netgml3_2MappingRule', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 923, 1), )

    
    MappingRule = property(__MappingRule.value, __MappingRule.set, None, '')

    _ElementMap.update({
        __CoverageMappingRule.name() : __CoverageMappingRule,
        __GridFunction.name() : __GridFunction,
        __MappingRule.name() : __MappingRule
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.CoverageFunctionType = CoverageFunctionType
_Namespace_gml.addCategoryObject('typeBinding', 'CoverageFunctionType', CoverageFunctionType)


# Complex type {http://www.opengis.net/gml/3.2}MappingRuleType with content type ELEMENT_ONLY
class MappingRuleType (pyxb.binding.basis.complexTypeDefinition):
    """Complex type {http://www.opengis.net/gml/3.2}MappingRuleType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'MappingRuleType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coverage.xsd', 179, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.opengis.net/gml/3.2}ruleDefinition uses Python identifier ruleDefinition
    __ruleDefinition = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'ruleDefinition'), 'ruleDefinition', '__httpwww_opengis_netgml3_2_MappingRuleType_httpwww_opengis_netgml3_2ruleDefinition', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coverage.xsd', 181, 3), )

    
    ruleDefinition = property(__ruleDefinition.value, __ruleDefinition.set, None, None)

    
    # Element {http://www.opengis.net/gml/3.2}ruleReference uses Python identifier ruleReference
    __ruleReference = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'ruleReference'), 'ruleReference', '__httpwww_opengis_netgml3_2_MappingRuleType_httpwww_opengis_netgml3_2ruleReference', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coverage.xsd', 182, 3), )

    
    ruleReference = property(__ruleReference.value, __ruleReference.set, None, None)

    _ElementMap.update({
        __ruleDefinition.name() : __ruleDefinition,
        __ruleReference.name() : __ruleReference
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.MappingRuleType = MappingRuleType
_Namespace_gml.addCategoryObject('typeBinding', 'MappingRuleType', MappingRuleType)


# Complex type {http://www.opengis.net/gml/3.2}GridFunctionType with content type ELEMENT_ONLY
class GridFunctionType (pyxb.binding.basis.complexTypeDefinition):
    """Complex type {http://www.opengis.net/gml/3.2}GridFunctionType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'GridFunctionType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coverage.xsd', 191, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.opengis.net/gml/3.2}sequenceRule uses Python identifier sequenceRule
    __sequenceRule = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'sequenceRule'), 'sequenceRule', '__httpwww_opengis_netgml3_2_GridFunctionType_httpwww_opengis_netgml3_2sequenceRule', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coverage.xsd', 193, 3), )

    
    sequenceRule = property(__sequenceRule.value, __sequenceRule.set, None, None)

    
    # Element {http://www.opengis.net/gml/3.2}startPoint uses Python identifier startPoint
    __startPoint = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'startPoint'), 'startPoint', '__httpwww_opengis_netgml3_2_GridFunctionType_httpwww_opengis_netgml3_2startPoint', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coverage.xsd', 194, 3), )

    
    startPoint = property(__startPoint.value, __startPoint.set, None, None)

    _ElementMap.update({
        __sequenceRule.name() : __sequenceRule,
        __startPoint.name() : __startPoint
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.GridFunctionType = GridFunctionType
_Namespace_gml.addCategoryObject('typeBinding', 'GridFunctionType', GridFunctionType)


# Complex type [anonymous] with content type ELEMENT_ONLY
class CTD_ANON (pyxb.binding.basis.complexTypeDefinition):
    """gml:secondDefiningParameter is a property containing the definition of the second parameter that defines the shape of an ellipsoid. An ellipsoid requires two defining parameters: semi-major axis and inverse flattening or semi-major axis and semi-minor axis. When the reference body is a sphere rather than an ellipsoid, only a single defining parameter is required, namely the radius of the sphere; in that case, the semi-major axis "degenerates" into the radius of the sphere.
The inverseFlattening element contains the inverse flattening value of the ellipsoid. This value is a scale factor (or ratio). It uses gml:LengthType with the restriction that the unit of measure referenced by the uom attribute must be suitable for a scale factor, such as percent, permil, or parts-per-million.
The semiMinorAxis element contains the length of the semi-minor axis of the ellipsoid. When the isSphere element is included, the ellipsoid is degenerate and is actually a sphere. The sphere is completely defined by the semi-major axis, which is the radius of the sphere."""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = None
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/datums.xsd', 121, 2)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.opengis.net/gml/3.2}SecondDefiningParameter uses Python identifier SecondDefiningParameter
    __SecondDefiningParameter = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'SecondDefiningParameter'), 'SecondDefiningParameter', '__httpwww_opengis_netgml3_2_CTD_ANON_httpwww_opengis_netgml3_2SecondDefiningParameter', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/datums.xsd', 127, 1), )

    
    SecondDefiningParameter = property(__SecondDefiningParameter.value, __SecondDefiningParameter.set, None, None)

    _ElementMap.update({
        __SecondDefiningParameter.name() : __SecondDefiningParameter
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.CTD_ANON = CTD_ANON


# Complex type [anonymous] with content type ELEMENT_ONLY
class CTD_ANON_ (pyxb.binding.basis.complexTypeDefinition):
    """Complex type [anonymous] with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = None
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/datums.xsd', 128, 2)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.opengis.net/gml/3.2}inverseFlattening uses Python identifier inverseFlattening
    __inverseFlattening = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'inverseFlattening'), 'inverseFlattening', '__httpwww_opengis_netgml3_2_CTD_ANON__httpwww_opengis_netgml3_2inverseFlattening', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/datums.xsd', 130, 4), )

    
    inverseFlattening = property(__inverseFlattening.value, __inverseFlattening.set, None, None)

    
    # Element {http://www.opengis.net/gml/3.2}semiMinorAxis uses Python identifier semiMinorAxis
    __semiMinorAxis = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'semiMinorAxis'), 'semiMinorAxis', '__httpwww_opengis_netgml3_2_CTD_ANON__httpwww_opengis_netgml3_2semiMinorAxis', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/datums.xsd', 131, 4), )

    
    semiMinorAxis = property(__semiMinorAxis.value, __semiMinorAxis.set, None, None)

    
    # Element {http://www.opengis.net/gml/3.2}isSphere uses Python identifier isSphere
    __isSphere = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'isSphere'), 'isSphere', '__httpwww_opengis_netgml3_2_CTD_ANON__httpwww_opengis_netgml3_2isSphere', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/datums.xsd', 132, 4), )

    
    isSphere = property(__isSphere.value, __isSphere.set, None, None)

    _ElementMap.update({
        __inverseFlattening.name() : __inverseFlattening,
        __semiMinorAxis.name() : __semiMinorAxis,
        __isSphere.name() : __isSphere
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.CTD_ANON_ = CTD_ANON_


# Complex type {http://www.opengis.net/gml/3.2}DMSAngleType with content type ELEMENT_ONLY
class DMSAngleType (pyxb.binding.basis.complexTypeDefinition):
    """"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'DMSAngleType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 539, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.opengis.net/gml/3.2}degrees uses Python identifier degrees
    __degrees = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'degrees'), 'degrees', '__httpwww_opengis_netgml3_2_DMSAngleType_httpwww_opengis_netgml3_2degrees', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 554, 1), )

    
    degrees = property(__degrees.value, __degrees.set, None, '')

    
    # Element {http://www.opengis.net/gml/3.2}decimalMinutes uses Python identifier decimalMinutes
    __decimalMinutes = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'decimalMinutes'), 'decimalMinutes', '__httpwww_opengis_netgml3_2_DMSAngleType_httpwww_opengis_netgml3_2decimalMinutes', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 588, 1), )

    
    decimalMinutes = property(__decimalMinutes.value, __decimalMinutes.set, None, '')

    
    # Element {http://www.opengis.net/gml/3.2}minutes uses Python identifier minutes
    __minutes = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'minutes'), 'minutes', '__httpwww_opengis_netgml3_2_DMSAngleType_httpwww_opengis_netgml3_2minutes', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 602, 1), )

    
    minutes = property(__minutes.value, __minutes.set, None, '')

    
    # Element {http://www.opengis.net/gml/3.2}seconds uses Python identifier seconds
    __seconds = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'seconds'), 'seconds', '__httpwww_opengis_netgml3_2_DMSAngleType_httpwww_opengis_netgml3_2seconds', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 615, 1), )

    
    seconds = property(__seconds.value, __seconds.set, None, '')

    _ElementMap.update({
        __degrees.name() : __degrees,
        __decimalMinutes.name() : __decimalMinutes,
        __minutes.name() : __minutes,
        __seconds.name() : __seconds
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.DMSAngleType = DMSAngleType
_Namespace_gml.addCategoryObject('typeBinding', 'DMSAngleType', DMSAngleType)


# Complex type {http://www.opengis.net/gml/3.2}AngleChoiceType with content type ELEMENT_ONLY
class AngleChoiceType (pyxb.binding.basis.complexTypeDefinition):
    """"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'AngleChoiceType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 629, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.opengis.net/gml/3.2}dmsAngle uses Python identifier dmsAngle
    __dmsAngle = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'dmsAngle'), 'dmsAngle', '__httpwww_opengis_netgml3_2_AngleChoiceType_httpwww_opengis_netgml3_2dmsAngle', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 534, 1), )

    
    dmsAngle = property(__dmsAngle.value, __dmsAngle.set, None, '')

    
    # Element {http://www.opengis.net/gml/3.2}angle uses Python identifier angle
    __angle = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'angle'), 'angle', '__httpwww_opengis_netgml3_2_AngleChoiceType_httpwww_opengis_netgml3_2angle', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/measures.xsd', 63, 1), )

    
    angle = property(__angle.value, __angle.set, None, 'The gml:angle property element is used to record the value of an angle quantity as a single number, with its units.')

    _ElementMap.update({
        __dmsAngle.name() : __dmsAngle,
        __angle.name() : __angle
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.AngleChoiceType = AngleChoiceType
_Namespace_gml.addCategoryObject('typeBinding', 'AngleChoiceType', AngleChoiceType)


# Complex type {http://www.opengis.net/gml/3.2}ArrayAssociationType with content type ELEMENT_ONLY
class ArrayAssociationType (pyxb.binding.basis.complexTypeDefinition):
    """"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'ArrayAssociationType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 648, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.opengis.net/gml/3.2}AbstractObject uses Python identifier AbstractObject
    __AbstractObject = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractObject'), 'AbstractObject', '__httpwww_opengis_netgml3_2_ArrayAssociationType_httpwww_opengis_netgml3_2AbstractObject', True, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 21, 1), )

    
    AbstractObject = property(__AbstractObject.value, __AbstractObject.set, None, 'This element has no type defined, and is therefore implicitly (according to the rules of W3C XML Schema) an XML Schema anyType. It is used as the head of an XML Schema substitution group which unifies complex content and certain simple content elements used for datatypes in GML, including the gml:AbstractGML substitution group.')

    
    # Attribute owns uses Python identifier owns
    __owns = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'owns'), 'owns', '__httpwww_opengis_netgml3_2_ArrayAssociationType_owns', pyxb.binding.datatypes.boolean, unicode_default='false')
    __owns._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 79, 2)
    __owns._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 79, 2)
    
    owns = property(__owns.value, __owns.set, None, None)

    _ElementMap.update({
        __AbstractObject.name() : __AbstractObject
    })
    _AttributeMap.update({
        __owns.name() : __owns
    })
_module_typeBindings.ArrayAssociationType = ArrayAssociationType
_Namespace_gml.addCategoryObject('typeBinding', 'ArrayAssociationType', ArrayAssociationType)


# Complex type {http://www.opengis.net/gml/3.2}AbstractMetaDataType with content type MIXED
class AbstractMetaDataType (pyxb.binding.basis.complexTypeDefinition):
    """"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_MIXED
    _Abstract = True
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractMetaDataType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 727, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Attribute {http://www.opengis.net/gml/3.2}id uses Python identifier id
    __id = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gml, 'id'), 'id', '__httpwww_opengis_netgml3_2_AbstractMetaDataType_httpwww_opengis_netgml3_2id', pyxb.binding.datatypes.ID)
    __id._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 137, 1)
    __id._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 732, 2)
    
    id = property(__id.value, __id.set, None, 'The attribute gml:id supports provision of a handle for the XML element representing a GML Object. Its use is mandatory for all GML objects. It is of XML type ID, so is constrained to be unique in the XML document within which it occurs.')

    _ElementMap.update({
        
    })
    _AttributeMap.update({
        __id.name() : __id
    })
_module_typeBindings.AbstractMetaDataType = AbstractMetaDataType
_Namespace_gml.addCategoryObject('typeBinding', 'AbstractMetaDataType', AbstractMetaDataType)


# Complex type {http://www.opengis.net/gml/3.2}FeatureArrayPropertyType with content type ELEMENT_ONLY
class FeatureArrayPropertyType (pyxb.binding.basis.complexTypeDefinition):
    """"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'FeatureArrayPropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 815, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.opengis.net/gml/3.2}AbstractFeature uses Python identifier AbstractFeature
    __AbstractFeature = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractFeature'), 'AbstractFeature', '__httpwww_opengis_netgml3_2_FeatureArrayPropertyType_httpwww_opengis_netgml3_2AbstractFeature', True, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/feature.xsd', 32, 1), )

    
    AbstractFeature = property(__AbstractFeature.value, __AbstractFeature.set, None, 'This abstract element serves as the head of a substitution group which may contain any elements whose content model is derived from gml:AbstractFeatureType.  This may be used as a variable in the construction of content models.  \ngml:AbstractFeature may be thought of as "anything that is a GML feature" and may be used to define variables or templates in which the value of a GML property is "any feature". This occurs in particular in a GML feature collection where the feature member properties contain one or multiple copies of gml:AbstractFeature respectively.')

    _ElementMap.update({
        __AbstractFeature.name() : __AbstractFeature
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.FeatureArrayPropertyType = FeatureArrayPropertyType
_Namespace_gml.addCategoryObject('typeBinding', 'FeatureArrayPropertyType', FeatureArrayPropertyType)


# Complex type {http://www.opengis.net/gml/3.2}IndirectEntryType with content type ELEMENT_ONLY
class IndirectEntryType (pyxb.binding.basis.complexTypeDefinition):
    """"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'IndirectEntryType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 893, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.opengis.net/gml/3.2}DefinitionProxy uses Python identifier DefinitionProxy
    __DefinitionProxy = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'DefinitionProxy'), 'DefinitionProxy', '__httpwww_opengis_netgml3_2_IndirectEntryType_httpwww_opengis_netgml3_2DefinitionProxy', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 901, 1), )

    
    DefinitionProxy = property(__DefinitionProxy.value, __DefinitionProxy.set, None, '')

    _ElementMap.update({
        __DefinitionProxy.name() : __DefinitionProxy
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.IndirectEntryType = IndirectEntryType
_Namespace_gml.addCategoryObject('typeBinding', 'IndirectEntryType', IndirectEntryType)


# Complex type {http://www.opengis.net/gml/3.2}DirectionVectorType with content type ELEMENT_ONLY
class DirectionVectorType (pyxb.binding.basis.complexTypeDefinition):
    """Direction vectors are specified by providing components of a vector."""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'DirectionVectorType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/direction.xsd', 31, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.opengis.net/gml/3.2}horizontalAngle uses Python identifier horizontalAngle
    __horizontalAngle = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'horizontalAngle'), 'horizontalAngle', '__httpwww_opengis_netgml3_2_DirectionVectorType_httpwww_opengis_netgml3_2horizontalAngle', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/direction.xsd', 41, 4), )

    
    horizontalAngle = property(__horizontalAngle.value, __horizontalAngle.set, None, None)

    
    # Element {http://www.opengis.net/gml/3.2}verticalAngle uses Python identifier verticalAngle
    __verticalAngle = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'verticalAngle'), 'verticalAngle', '__httpwww_opengis_netgml3_2_DirectionVectorType_httpwww_opengis_netgml3_2verticalAngle', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/direction.xsd', 42, 4), )

    
    verticalAngle = property(__verticalAngle.value, __verticalAngle.set, None, None)

    
    # Element {http://www.opengis.net/gml/3.2}vector uses Python identifier vector
    __vector = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'vector'), 'vector', '__httpwww_opengis_netgml3_2_DirectionVectorType_httpwww_opengis_netgml3_2vector', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic0d1d.xsd', 132, 1), )

    
    vector = property(__vector.value, __vector.set, None, None)

    _ElementMap.update({
        __horizontalAngle.name() : __horizontalAngle,
        __verticalAngle.name() : __verticalAngle,
        __vector.name() : __vector
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.DirectionVectorType = DirectionVectorType
_Namespace_gml.addCategoryObject('typeBinding', 'DirectionVectorType', DirectionVectorType)


# Complex type {http://www.opengis.net/gml/3.2}DirectionDescriptionType with content type ELEMENT_ONLY
class DirectionDescriptionType (pyxb.binding.basis.complexTypeDefinition):
    """direction descriptions are specified by a compass point code, a keyword, a textual description or a reference to a description.
A gml:compassPoint is specified by a simple enumeration.  	
In addition, thre elements to contain text-based descriptions of direction are provided.  
If the direction is specified using a term from a list, gml:keyword should be used, and the list indicated using the value of the codeSpace attribute. 
if the direction is decribed in prose, gml:direction or gml:reference should be used, allowing the value to be included inline or by reference."""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'DirectionDescriptionType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/direction.xsd', 46, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.opengis.net/gml/3.2}compassPoint uses Python identifier compassPoint
    __compassPoint = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'compassPoint'), 'compassPoint', '__httpwww_opengis_netgml3_2_DirectionDescriptionType_httpwww_opengis_netgml3_2compassPoint', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/direction.xsd', 55, 3), )

    
    compassPoint = property(__compassPoint.value, __compassPoint.set, None, None)

    
    # Element {http://www.opengis.net/gml/3.2}keyword uses Python identifier keyword
    __keyword = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'keyword'), 'keyword', '__httpwww_opengis_netgml3_2_DirectionDescriptionType_httpwww_opengis_netgml3_2keyword', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/direction.xsd', 56, 3), )

    
    keyword = property(__keyword.value, __keyword.set, None, None)

    
    # Element {http://www.opengis.net/gml/3.2}description uses Python identifier description
    __description = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'description'), 'description', '__httpwww_opengis_netgml3_2_DirectionDescriptionType_httpwww_opengis_netgml3_2description', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/direction.xsd', 57, 3), )

    
    description = property(__description.value, __description.set, None, None)

    
    # Element {http://www.opengis.net/gml/3.2}reference uses Python identifier reference
    __reference = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'reference'), 'reference', '__httpwww_opengis_netgml3_2_DirectionDescriptionType_httpwww_opengis_netgml3_2reference', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/direction.xsd', 58, 3), )

    
    reference = property(__reference.value, __reference.set, None, None)

    _ElementMap.update({
        __compassPoint.name() : __compassPoint,
        __keyword.name() : __keyword,
        __description.name() : __description,
        __reference.name() : __reference
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.DirectionDescriptionType = DirectionDescriptionType
_Namespace_gml.addCategoryObject('typeBinding', 'DirectionDescriptionType', DirectionDescriptionType)


# Complex type {http://www.opengis.net/gml/3.2}HistoryPropertyType with content type ELEMENT_ONLY
class HistoryPropertyType (pyxb.binding.basis.complexTypeDefinition):
    """Complex type {http://www.opengis.net/gml/3.2}HistoryPropertyType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'HistoryPropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dynamicFeature.xsd', 103, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.opengis.net/gml/3.2}AbstractTimeSlice uses Python identifier AbstractTimeSlice
    __AbstractTimeSlice = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractTimeSlice'), 'AbstractTimeSlice', '__httpwww_opengis_netgml3_2_HistoryPropertyType_httpwww_opengis_netgml3_2AbstractTimeSlice', True, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dynamicFeature.xsd', 78, 1), )

    
    AbstractTimeSlice = property(__AbstractTimeSlice.value, __AbstractTimeSlice.set, None, 'To describe an event — an action that occurs at an instant or over an interval of time — GML provides the gml:AbtractTimeSlice element. A timeslice encapsulates the time-varying properties of a dynamic feature -- it shall be extended to represent a time stamped projection of a specific feature. The gml:dataSource property describes how the temporal data was acquired.\nA gml:AbstractTimeSlice instance is a GML object that encapsulates updates of the dynamic—or volatile—properties that reflect some change event; it thus includes only those feature properties that have actually changed due to some process.\ngml:AbstractTimeSlice basically provides a facility for attribute-level time stamping, in contrast to the object-level time stamping of dynamic feature instances. \nThe time slice can thus be viewed as event or process-oriented, whereas a snapshot is more state or structure-oriented. A timeslice has richer causality, whereas a snapshot merely portrays the status of the whole. \n')

    
    # Attribute owns uses Python identifier owns
    __owns = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'owns'), 'owns', '__httpwww_opengis_netgml3_2_HistoryPropertyType_owns', pyxb.binding.datatypes.boolean, unicode_default='false')
    __owns._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 79, 2)
    __owns._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 79, 2)
    
    owns = property(__owns.value, __owns.set, None, None)

    _ElementMap.update({
        __AbstractTimeSlice.name() : __AbstractTimeSlice
    })
    _AttributeMap.update({
        __owns.name() : __owns
    })
_module_typeBindings.HistoryPropertyType = HistoryPropertyType
_Namespace_gml.addCategoryObject('typeBinding', 'HistoryPropertyType', HistoryPropertyType)


# Complex type {http://www.opengis.net/gml/3.2}AbstractFeatureMemberType with content type EMPTY
class AbstractFeatureMemberType (pyxb.binding.basis.complexTypeDefinition):
    """To create a collection of GML features, a property type shall be derived by extension from gml:AbstractFeatureMemberType.
By default, this abstract property type does not imply any ownership of the features in the collection. The owns attribute of gml:OwnershipAttributeGroup may be used on a property element instance to assert ownership of a feature in the collection. A collection shall not own a feature already owned by another object."""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_EMPTY
    _Abstract = True
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractFeatureMemberType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/feature.xsd', 86, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Attribute owns uses Python identifier owns
    __owns = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'owns'), 'owns', '__httpwww_opengis_netgml3_2_AbstractFeatureMemberType_owns', pyxb.binding.datatypes.boolean, unicode_default='false')
    __owns._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 79, 2)
    __owns._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 79, 2)
    
    owns = property(__owns.value, __owns.set, None, None)

    _ElementMap.update({
        
    })
    _AttributeMap.update({
        __owns.name() : __owns
    })
_module_typeBindings.AbstractFeatureMemberType = AbstractFeatureMemberType
_Namespace_gml.addCategoryObject('typeBinding', 'AbstractFeatureMemberType', AbstractFeatureMemberType)


# Complex type {http://www.opengis.net/gml/3.2}GeometryArrayPropertyType with content type ELEMENT_ONLY
class GeometryArrayPropertyType (pyxb.binding.basis.complexTypeDefinition):
    """If a feature has a property which takes an array of geometry elements as its value, this is called a geometry array property. A generic type for such a geometry property is GeometryArrayPropertyType. 
The elements are always contained inline in the array property, referencing geometry elements or arrays of geometry elements via XLinks is not supported."""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'GeometryArrayPropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic0d1d.xsd', 66, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.opengis.net/gml/3.2}AbstractGeometry uses Python identifier AbstractGeometry
    __AbstractGeometry = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractGeometry'), 'AbstractGeometry', '__httpwww_opengis_netgml3_2_GeometryArrayPropertyType_httpwww_opengis_netgml3_2AbstractGeometry', True, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic0d1d.xsd', 50, 1), )

    
    AbstractGeometry = property(__AbstractGeometry.value, __AbstractGeometry.set, None, 'The AbstractGeometry element is the abstract head of the substitution group for all geometry elements of GML. This includes pre-defined and user-defined geometry elements. Any geometry element shall be a direct or indirect extension/restriction of AbstractGeometryType and shall be directly or indirectly in the substitution group of AbstractGeometry.')

    
    # Attribute owns uses Python identifier owns
    __owns = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'owns'), 'owns', '__httpwww_opengis_netgml3_2_GeometryArrayPropertyType_owns', pyxb.binding.datatypes.boolean, unicode_default='false')
    __owns._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 79, 2)
    __owns._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 79, 2)
    
    owns = property(__owns.value, __owns.set, None, None)

    _ElementMap.update({
        __AbstractGeometry.name() : __AbstractGeometry
    })
    _AttributeMap.update({
        __owns.name() : __owns
    })
_module_typeBindings.GeometryArrayPropertyType = GeometryArrayPropertyType
_Namespace_gml.addCategoryObject('typeBinding', 'GeometryArrayPropertyType', GeometryArrayPropertyType)


# Complex type {http://www.opengis.net/gml/3.2}PointArrayPropertyType with content type ELEMENT_ONLY
class PointArrayPropertyType (pyxb.binding.basis.complexTypeDefinition):
    """gml:PointArrayPropertyType is a container for an array of points. The elements are always contained inline in the array property, referencing geometry elements or arrays of geometry elements via XLinks is not supported."""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'PointArrayPropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic0d1d.xsd', 209, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.opengis.net/gml/3.2}Point uses Python identifier Point
    __Point = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'Point'), 'Point', '__httpwww_opengis_netgml3_2_PointArrayPropertyType_httpwww_opengis_netgml3_2Point', True, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic0d1d.xsd', 189, 1), )

    
    Point = property(__Point.value, __Point.set, None, 'A Point is defined by a single coordinate tuple. The direct position of a point is specified by the pos element which is of type DirectPositionType.')

    
    # Attribute owns uses Python identifier owns
    __owns = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'owns'), 'owns', '__httpwww_opengis_netgml3_2_PointArrayPropertyType_owns', pyxb.binding.datatypes.boolean, unicode_default='false')
    __owns._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 79, 2)
    __owns._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 79, 2)
    
    owns = property(__owns.value, __owns.set, None, None)

    _ElementMap.update({
        __Point.name() : __Point
    })
    _AttributeMap.update({
        __owns.name() : __owns
    })
_module_typeBindings.PointArrayPropertyType = PointArrayPropertyType
_Namespace_gml.addCategoryObject('typeBinding', 'PointArrayPropertyType', PointArrayPropertyType)


# Complex type {http://www.opengis.net/gml/3.2}CurveArrayPropertyType with content type ELEMENT_ONLY
class CurveArrayPropertyType (pyxb.binding.basis.complexTypeDefinition):
    """A container for an array of curves. The elements are always contained in the array property, referencing geometry elements or arrays of geometry elements via XLinks is not supported."""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'CurveArrayPropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic0d1d.xsd', 246, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.opengis.net/gml/3.2}AbstractCurve uses Python identifier AbstractCurve
    __AbstractCurve = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractCurve'), 'AbstractCurve', '__httpwww_opengis_netgml3_2_CurveArrayPropertyType_httpwww_opengis_netgml3_2AbstractCurve', True, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic0d1d.xsd', 226, 1), )

    
    AbstractCurve = property(__AbstractCurve.value, __AbstractCurve.set, None, 'The AbstractCurve element is the abstract head of the substitution group for all (continuous) curve elements.')

    
    # Attribute owns uses Python identifier owns
    __owns = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'owns'), 'owns', '__httpwww_opengis_netgml3_2_CurveArrayPropertyType_owns', pyxb.binding.datatypes.boolean, unicode_default='false')
    __owns._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 79, 2)
    __owns._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 79, 2)
    
    owns = property(__owns.value, __owns.set, None, None)

    _ElementMap.update({
        __AbstractCurve.name() : __AbstractCurve
    })
    _AttributeMap.update({
        __owns.name() : __owns
    })
_module_typeBindings.CurveArrayPropertyType = CurveArrayPropertyType
_Namespace_gml.addCategoryObject('typeBinding', 'CurveArrayPropertyType', CurveArrayPropertyType)


# Complex type {http://www.opengis.net/gml/3.2}SurfaceArrayPropertyType with content type ELEMENT_ONLY
class SurfaceArrayPropertyType (pyxb.binding.basis.complexTypeDefinition):
    """gml:SurfaceArrayPropertyType is a container for an array of surfaces. The elements are always contained in the array property, referencing geometry elements or arrays of geometry elements via XLinks is not supported."""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'SurfaceArrayPropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic2d.xsd', 42, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.opengis.net/gml/3.2}AbstractSurface uses Python identifier AbstractSurface
    __AbstractSurface = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractSurface'), 'AbstractSurface', '__httpwww_opengis_netgml3_2_SurfaceArrayPropertyType_httpwww_opengis_netgml3_2AbstractSurface', True, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic2d.xsd', 22, 1), )

    
    AbstractSurface = property(__AbstractSurface.value, __AbstractSurface.set, None, 'The AbstractSurface element is the abstract head of the substitution group for all (continuous) surface elements.')

    
    # Attribute owns uses Python identifier owns
    __owns = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'owns'), 'owns', '__httpwww_opengis_netgml3_2_SurfaceArrayPropertyType_owns', pyxb.binding.datatypes.boolean, unicode_default='false')
    __owns._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 79, 2)
    __owns._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 79, 2)
    
    owns = property(__owns.value, __owns.set, None, None)

    _ElementMap.update({
        __AbstractSurface.name() : __AbstractSurface
    })
    _AttributeMap.update({
        __owns.name() : __owns
    })
_module_typeBindings.SurfaceArrayPropertyType = SurfaceArrayPropertyType
_Namespace_gml.addCategoryObject('typeBinding', 'SurfaceArrayPropertyType', SurfaceArrayPropertyType)


# Complex type {http://www.opengis.net/gml/3.2}AbstractRingPropertyType with content type ELEMENT_ONLY
class AbstractRingPropertyType (pyxb.binding.basis.complexTypeDefinition):
    """A property with the content model of gml:AbstractRingPropertyType encapsulates a ring to represent the surface boundary property of a surface."""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractRingPropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic2d.xsd', 90, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.opengis.net/gml/3.2}AbstractRing uses Python identifier AbstractRing
    __AbstractRing = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractRing'), 'AbstractRing', '__httpwww_opengis_netgml3_2_AbstractRingPropertyType_httpwww_opengis_netgml3_2AbstractRing', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic2d.xsd', 84, 1), )

    
    AbstractRing = property(__AbstractRing.value, __AbstractRing.set, None, 'An abstraction of a ring to support surface boundaries of different complexity.\nThe AbstractRing element is the abstract head of the substituition group for all closed boundaries of a surface patch.')

    _ElementMap.update({
        __AbstractRing.name() : __AbstractRing
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.AbstractRingPropertyType = AbstractRingPropertyType
_Namespace_gml.addCategoryObject('typeBinding', 'AbstractRingPropertyType', AbstractRingPropertyType)


# Complex type {http://www.opengis.net/gml/3.2}LinearRingPropertyType with content type ELEMENT_ONLY
class LinearRingPropertyType (pyxb.binding.basis.complexTypeDefinition):
    """A property with the content model of gml:LinearRingPropertyType encapsulates a linear ring to represent a component of a surface boundary."""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'LinearRingPropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic2d.xsd', 120, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.opengis.net/gml/3.2}LinearRing uses Python identifier LinearRing
    __LinearRing = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'LinearRing'), 'LinearRing', '__httpwww_opengis_netgml3_2_LinearRingPropertyType_httpwww_opengis_netgml3_2LinearRing', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic2d.xsd', 115, 1), )

    
    LinearRing = property(__LinearRing.value, __LinearRing.set, None, 'A LinearRing is defined by four or more coordinate tuples, with linear interpolation between them; the first and last coordinates shall be coincident. The number of direct positions in the list shall be at least four.')

    _ElementMap.update({
        __LinearRing.name() : __LinearRing
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.LinearRingPropertyType = LinearRingPropertyType
_Namespace_gml.addCategoryObject('typeBinding', 'LinearRingPropertyType', LinearRingPropertyType)


# Complex type {http://www.opengis.net/gml/3.2}AbstractCurveSegmentType with content type EMPTY
class AbstractCurveSegmentType (pyxb.binding.basis.complexTypeDefinition):
    """Complex type {http://www.opengis.net/gml/3.2}AbstractCurveSegmentType with content type EMPTY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_EMPTY
    _Abstract = True
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractCurveSegmentType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 52, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Attribute numDerivativesAtStart uses Python identifier numDerivativesAtStart
    __numDerivativesAtStart = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'numDerivativesAtStart'), 'numDerivativesAtStart', '__httpwww_opengis_netgml3_2_AbstractCurveSegmentType_numDerivativesAtStart', pyxb.binding.datatypes.integer, unicode_default='0')
    __numDerivativesAtStart._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 53, 2)
    __numDerivativesAtStart._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 53, 2)
    
    numDerivativesAtStart = property(__numDerivativesAtStart.value, __numDerivativesAtStart.set, None, None)

    
    # Attribute numDerivativesAtEnd uses Python identifier numDerivativesAtEnd
    __numDerivativesAtEnd = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'numDerivativesAtEnd'), 'numDerivativesAtEnd', '__httpwww_opengis_netgml3_2_AbstractCurveSegmentType_numDerivativesAtEnd', pyxb.binding.datatypes.integer, unicode_default='0')
    __numDerivativesAtEnd._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 54, 2)
    __numDerivativesAtEnd._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 54, 2)
    
    numDerivativesAtEnd = property(__numDerivativesAtEnd.value, __numDerivativesAtEnd.set, None, None)

    
    # Attribute numDerivativeInterior uses Python identifier numDerivativeInterior
    __numDerivativeInterior = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'numDerivativeInterior'), 'numDerivativeInterior', '__httpwww_opengis_netgml3_2_AbstractCurveSegmentType_numDerivativeInterior', pyxb.binding.datatypes.integer, unicode_default='0')
    __numDerivativeInterior._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 55, 2)
    __numDerivativeInterior._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 55, 2)
    
    numDerivativeInterior = property(__numDerivativeInterior.value, __numDerivativeInterior.set, None, None)

    _ElementMap.update({
        
    })
    _AttributeMap.update({
        __numDerivativesAtStart.name() : __numDerivativesAtStart,
        __numDerivativesAtEnd.name() : __numDerivativesAtEnd,
        __numDerivativeInterior.name() : __numDerivativeInterior
    })
_module_typeBindings.AbstractCurveSegmentType = AbstractCurveSegmentType
_Namespace_gml.addCategoryObject('typeBinding', 'AbstractCurveSegmentType', AbstractCurveSegmentType)


# Complex type {http://www.opengis.net/gml/3.2}CurveSegmentArrayPropertyType with content type ELEMENT_ONLY
class CurveSegmentArrayPropertyType (pyxb.binding.basis.complexTypeDefinition):
    """gml:CurveSegmentArrayPropertyType is a container for an array of curve segments."""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'CurveSegmentArrayPropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 65, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.opengis.net/gml/3.2}AbstractCurveSegment uses Python identifier AbstractCurveSegment
    __AbstractCurveSegment = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractCurveSegment'), 'AbstractCurveSegment', '__httpwww_opengis_netgml3_2_CurveSegmentArrayPropertyType_httpwww_opengis_netgml3_2AbstractCurveSegment', True, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 57, 1), )

    
    AbstractCurveSegment = property(__AbstractCurveSegment.value, __AbstractCurveSegment.set, None, 'A curve segment defines a homogeneous segment of a curve.\nThe attributes numDerivativesAtStart, numDerivativesAtEnd and numDerivativesInterior specify the type of continuity as specified in ISO 19107:2003, 6.4.9.3.\nThe AbstractCurveSegment element is the abstract head of the substituition group for all curve segment elements, i.e. continuous segments of the same interpolation mechanism.\nAll curve segments shall have an attribute interpolation with type gml:CurveInterpolationType specifying the curve interpolation mechanism used for this segment. This mechanism uses the control points and control parameters to determine the position of this curve segment.')

    _ElementMap.update({
        __AbstractCurveSegment.name() : __AbstractCurveSegment
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.CurveSegmentArrayPropertyType = CurveSegmentArrayPropertyType
_Namespace_gml.addCategoryObject('typeBinding', 'CurveSegmentArrayPropertyType', CurveSegmentArrayPropertyType)


# Complex type {http://www.opengis.net/gml/3.2}KnotType with content type ELEMENT_ONLY
class KnotType (pyxb.binding.basis.complexTypeDefinition):
    """Complex type {http://www.opengis.net/gml/3.2}KnotType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'KnotType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 351, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.opengis.net/gml/3.2}value uses Python identifier value_
    __value = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'value'), 'value_', '__httpwww_opengis_netgml3_2_KnotType_httpwww_opengis_netgml3_2value', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 353, 3), )

    
    value_ = property(__value.value, __value.set, None, None)

    
    # Element {http://www.opengis.net/gml/3.2}multiplicity uses Python identifier multiplicity
    __multiplicity = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'multiplicity'), 'multiplicity', '__httpwww_opengis_netgml3_2_KnotType_httpwww_opengis_netgml3_2multiplicity', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 354, 3), )

    
    multiplicity = property(__multiplicity.value, __multiplicity.set, None, None)

    
    # Element {http://www.opengis.net/gml/3.2}weight uses Python identifier weight
    __weight = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'weight'), 'weight', '__httpwww_opengis_netgml3_2_KnotType_httpwww_opengis_netgml3_2weight', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 355, 3), )

    
    weight = property(__weight.value, __weight.set, None, None)

    _ElementMap.update({
        __value.name() : __value,
        __multiplicity.name() : __multiplicity,
        __weight.name() : __weight
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.KnotType = KnotType
_Namespace_gml.addCategoryObject('typeBinding', 'KnotType', KnotType)


# Complex type {http://www.opengis.net/gml/3.2}KnotPropertyType with content type ELEMENT_ONLY
class KnotPropertyType (pyxb.binding.basis.complexTypeDefinition):
    """gml:KnotPropertyType encapsulates a knot to use it in a geometric type."""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'KnotPropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 358, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.opengis.net/gml/3.2}Knot uses Python identifier Knot
    __Knot = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'Knot'), 'Knot', '__httpwww_opengis_netgml3_2_KnotPropertyType_httpwww_opengis_netgml3_2Knot', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 363, 3), )

    
    Knot = property(__Knot.value, __Knot.set, None, 'A knot is a breakpoint on a piecewise spline curve.\nvalue is the value of the parameter at the knot of the spline (see ISO 19107:2003, 6.4.24.2).\nmultiplicity is the multiplicity of this knot used in the definition of the spline (with the same weight).\nweight is the value of the averaging weight used for this knot of the spline.')

    _ElementMap.update({
        __Knot.name() : __Knot
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.KnotPropertyType = KnotPropertyType
_Namespace_gml.addCategoryObject('typeBinding', 'KnotPropertyType', KnotPropertyType)


# Complex type {http://www.opengis.net/gml/3.2}AffinePlacementType with content type ELEMENT_ONLY
class AffinePlacementType (pyxb.binding.basis.complexTypeDefinition):
    """Complex type {http://www.opengis.net/gml/3.2}AffinePlacementType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'AffinePlacementType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 433, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.opengis.net/gml/3.2}location uses Python identifier location
    __location = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'location'), 'location', '__httpwww_opengis_netgml3_2_AffinePlacementType_httpwww_opengis_netgml3_2location', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 435, 3), )

    
    location = property(__location.value, __location.set, None, None)

    
    # Element {http://www.opengis.net/gml/3.2}refDirection uses Python identifier refDirection
    __refDirection = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'refDirection'), 'refDirection', '__httpwww_opengis_netgml3_2_AffinePlacementType_httpwww_opengis_netgml3_2refDirection', True, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 436, 3), )

    
    refDirection = property(__refDirection.value, __refDirection.set, None, None)

    
    # Element {http://www.opengis.net/gml/3.2}inDimension uses Python identifier inDimension
    __inDimension = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'inDimension'), 'inDimension', '__httpwww_opengis_netgml3_2_AffinePlacementType_httpwww_opengis_netgml3_2inDimension', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 437, 3), )

    
    inDimension = property(__inDimension.value, __inDimension.set, None, None)

    
    # Element {http://www.opengis.net/gml/3.2}outDimension uses Python identifier outDimension
    __outDimension = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'outDimension'), 'outDimension', '__httpwww_opengis_netgml3_2_AffinePlacementType_httpwww_opengis_netgml3_2outDimension', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 438, 3), )

    
    outDimension = property(__outDimension.value, __outDimension.set, None, None)

    _ElementMap.update({
        __location.name() : __location,
        __refDirection.name() : __refDirection,
        __inDimension.name() : __inDimension,
        __outDimension.name() : __outDimension
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.AffinePlacementType = AffinePlacementType
_Namespace_gml.addCategoryObject('typeBinding', 'AffinePlacementType', AffinePlacementType)


# Complex type [anonymous] with content type ELEMENT_ONLY
class CTD_ANON_2 (pyxb.binding.basis.complexTypeDefinition):
    """Complex type [anonymous] with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = None
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 451, 6)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.opengis.net/gml/3.2}AffinePlacement uses Python identifier AffinePlacement
    __AffinePlacement = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'AffinePlacement'), 'AffinePlacement', '__httpwww_opengis_netgml3_2_CTD_ANON_2_httpwww_opengis_netgml3_2AffinePlacement', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 441, 1), )

    
    AffinePlacement = property(__AffinePlacement.value, __AffinePlacement.set, None, 'location, refDirection, inDimension and outDimension have the same meaning as specified in ISO 19107:2003, 6.4.21.')

    _ElementMap.update({
        __AffinePlacement.name() : __AffinePlacement
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.CTD_ANON_2 = CTD_ANON_2


# Complex type {http://www.opengis.net/gml/3.2}AbstractSurfacePatchType with content type EMPTY
class AbstractSurfacePatchType (pyxb.binding.basis.complexTypeDefinition):
    """Complex type {http://www.opengis.net/gml/3.2}AbstractSurfacePatchType with content type EMPTY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_EMPTY
    _Abstract = True
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractSurfacePatchType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 533, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    _ElementMap.update({
        
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.AbstractSurfacePatchType = AbstractSurfacePatchType
_Namespace_gml.addCategoryObject('typeBinding', 'AbstractSurfacePatchType', AbstractSurfacePatchType)


# Complex type {http://www.opengis.net/gml/3.2}SurfacePatchArrayPropertyType with content type ELEMENT_ONLY
class SurfacePatchArrayPropertyType (pyxb.binding.basis.complexTypeDefinition):
    """gml:SurfacePatchArrayPropertyType is a container for a sequence of surface patches."""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'SurfacePatchArrayPropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 541, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.opengis.net/gml/3.2}AbstractSurfacePatch uses Python identifier AbstractSurfacePatch
    __AbstractSurfacePatch = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractSurfacePatch'), 'AbstractSurfacePatch', '__httpwww_opengis_netgml3_2_SurfacePatchArrayPropertyType_httpwww_opengis_netgml3_2AbstractSurfacePatch', True, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 534, 1), )

    
    AbstractSurfacePatch = property(__AbstractSurfacePatch.value, __AbstractSurfacePatch.set, None, 'A surface patch defines a homogenuous portion of a surface. \nThe AbstractSurfacePatch element is the abstract head of the substituition group for all surface patch elements describing a continuous portion of a surface.\nAll surface patches shall have an attribute interpolation (declared in the types derived from gml:AbstractSurfacePatchType) specifying the interpolation mechanism used for the patch using gml:SurfaceInterpolationType.')

    _ElementMap.update({
        __AbstractSurfacePatch.name() : __AbstractSurfacePatch
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.SurfacePatchArrayPropertyType = SurfacePatchArrayPropertyType
_Namespace_gml.addCategoryObject('typeBinding', 'SurfacePatchArrayPropertyType', SurfacePatchArrayPropertyType)


# Complex type {http://www.opengis.net/gml/3.2}RingPropertyType with content type ELEMENT_ONLY
class RingPropertyType (pyxb.binding.basis.complexTypeDefinition):
    """A property with the content model of gml:RingPropertyType encapsulates a ring to represent a component of a surface boundary."""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'RingPropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 640, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.opengis.net/gml/3.2}Ring uses Python identifier Ring
    __Ring = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'Ring'), 'Ring', '__httpwww_opengis_netgml3_2_RingPropertyType_httpwww_opengis_netgml3_2Ring', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 632, 1), )

    
    Ring = property(__Ring.value, __Ring.set, None, 'A ring is used to represent a single connected component of a surface boundary as specified in ISO 19107:2003, 6.3.6.\nEvery gml:curveMember references or contains one curve, i.e. any element which is substitutable for gml:AbstractCurve. In the context of a ring, the curves describe the boundary of the surface. The sequence of curves shall be contiguous and connected in a cycle.\nIf provided, the aggregationType attribute shall have the value "sequence".')

    _ElementMap.update({
        __Ring.name() : __Ring
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.RingPropertyType = RingPropertyType
_Namespace_gml.addCategoryObject('typeBinding', 'RingPropertyType', RingPropertyType)


# Complex type [anonymous] with content type ELEMENT_ONLY
class CTD_ANON_3 (pyxb.binding.basis.complexTypeDefinition):
    """Complex type [anonymous] with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = None
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 654, 4)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.opengis.net/gml/3.2}Row uses Python identifier Row
    __Row = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'Row'), 'Row', '__httpwww_opengis_netgml3_2_CTD_ANON_3_httpwww_opengis_netgml3_2Row', True, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 656, 6), )

    
    Row = property(__Row.value, __Row.set, None, None)

    _ElementMap.update({
        __Row.name() : __Row
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.CTD_ANON_3 = CTD_ANON_3


# Complex type [anonymous] with content type ELEMENT_ONLY
class CTD_ANON_4 (pyxb.binding.basis.complexTypeDefinition):
    """Complex type [anonymous] with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = None
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 657, 7)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.opengis.net/gml/3.2}pos uses Python identifier pos
    __pos = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'pos'), 'pos', '__httpwww_opengis_netgml3_2_CTD_ANON_4_httpwww_opengis_netgml3_2pos', True, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic0d1d.xsd', 87, 1), )

    
    pos = property(__pos.value, __pos.set, None, None)

    
    # Element {http://www.opengis.net/gml/3.2}posList uses Python identifier posList
    __posList = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'posList'), 'posList', '__httpwww_opengis_netgml3_2_CTD_ANON_4_httpwww_opengis_netgml3_2posList', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic0d1d.xsd', 102, 1), )

    
    posList = property(__posList.value, __posList.set, None, None)

    
    # Element {http://www.opengis.net/gml/3.2}pointProperty uses Python identifier pointProperty
    __pointProperty = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'pointProperty'), 'pointProperty', '__httpwww_opengis_netgml3_2_CTD_ANON_4_httpwww_opengis_netgml3_2pointProperty', True, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic0d1d.xsd', 204, 1), )

    
    pointProperty = property(__pointProperty.value, __pointProperty.set, None, 'This property element either references a point via the XLink-attributes or contains the point element. pointProperty is the predefined property which may be used by GML Application Schemas whenever a GML feature has a property with a value that is substitutable for Point.')

    _ElementMap.update({
        __pos.name() : __pos,
        __posList.name() : __posList,
        __pointProperty.name() : __pointProperty
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.CTD_ANON_4 = CTD_ANON_4


# Complex type [anonymous] with content type ELEMENT_ONLY
class CTD_ANON_5 (pyxb.binding.basis.complexTypeDefinition):
    """Complex type [anonymous] with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = None
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 743, 6)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.opengis.net/gml/3.2}pos uses Python identifier pos
    __pos = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'pos'), 'pos', '__httpwww_opengis_netgml3_2_CTD_ANON_5_httpwww_opengis_netgml3_2pos', True, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic0d1d.xsd', 87, 1), )

    
    pos = property(__pos.value, __pos.set, None, None)

    
    # Element {http://www.opengis.net/gml/3.2}posList uses Python identifier posList
    __posList = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'posList'), 'posList', '__httpwww_opengis_netgml3_2_CTD_ANON_5_httpwww_opengis_netgml3_2posList', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic0d1d.xsd', 102, 1), )

    
    posList = property(__posList.value, __posList.set, None, None)

    
    # Element {http://www.opengis.net/gml/3.2}pointProperty uses Python identifier pointProperty
    __pointProperty = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'pointProperty'), 'pointProperty', '__httpwww_opengis_netgml3_2_CTD_ANON_5_httpwww_opengis_netgml3_2pointProperty', True, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic0d1d.xsd', 204, 1), )

    
    pointProperty = property(__pointProperty.value, __pointProperty.set, None, 'This property element either references a point via the XLink-attributes or contains the point element. pointProperty is the predefined property which may be used by GML Application Schemas whenever a GML feature has a property with a value that is substitutable for Point.')

    _ElementMap.update({
        __pos.name() : __pos,
        __posList.name() : __posList,
        __pointProperty.name() : __pointProperty
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.CTD_ANON_5 = CTD_ANON_5


# Complex type {http://www.opengis.net/gml/3.2}LineStringSegmentArrayPropertyType with content type ELEMENT_ONLY
class LineStringSegmentArrayPropertyType (pyxb.binding.basis.complexTypeDefinition):
    """gml:LineStringSegmentArrayPropertyType provides a container for line strings."""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'LineStringSegmentArrayPropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 759, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.opengis.net/gml/3.2}LineStringSegment uses Python identifier LineStringSegment
    __LineStringSegment = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'LineStringSegment'), 'LineStringSegment', '__httpwww_opengis_netgml3_2_LineStringSegmentArrayPropertyType_httpwww_opengis_netgml3_2LineStringSegment', True, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 114, 1), )

    
    LineStringSegment = property(__LineStringSegment.value, __LineStringSegment.set, None, 'A LineStringSegment is a curve segment that is defined by two or more control points including the start and end point, with linear interpolation between them.\nThe content model follows the general pattern for the encoding of curve segments.')

    _ElementMap.update({
        __LineStringSegment.name() : __LineStringSegment
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.LineStringSegmentArrayPropertyType = LineStringSegmentArrayPropertyType
_Namespace_gml.addCategoryObject('typeBinding', 'LineStringSegmentArrayPropertyType', LineStringSegmentArrayPropertyType)


# Complex type {http://www.opengis.net/gml/3.2}SolidArrayPropertyType with content type ELEMENT_ONLY
class SolidArrayPropertyType (pyxb.binding.basis.complexTypeDefinition):
    """gml:SolidArrayPropertyType is a container for an array of solids. The elements are always contained in the array property, referencing geometry elements or arrays of geometry elements is not supported."""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'SolidArrayPropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 795, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.opengis.net/gml/3.2}AbstractSolid uses Python identifier AbstractSolid
    __AbstractSolid = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractSolid'), 'AbstractSolid', '__httpwww_opengis_netgml3_2_SolidArrayPropertyType_httpwww_opengis_netgml3_2AbstractSolid', True, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 775, 1), )

    
    AbstractSolid = property(__AbstractSolid.value, __AbstractSolid.set, None, 'The AbstractSolid element is the abstract head of the substituition group for all (continuous) solid elements.')

    
    # Attribute owns uses Python identifier owns
    __owns = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'owns'), 'owns', '__httpwww_opengis_netgml3_2_SolidArrayPropertyType_owns', pyxb.binding.datatypes.boolean, unicode_default='false')
    __owns._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 79, 2)
    __owns._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 79, 2)
    
    owns = property(__owns.value, __owns.set, None, None)

    _ElementMap.update({
        __AbstractSolid.name() : __AbstractSolid
    })
    _AttributeMap.update({
        __owns.name() : __owns
    })
_module_typeBindings.SolidArrayPropertyType = SolidArrayPropertyType
_Namespace_gml.addCategoryObject('typeBinding', 'SolidArrayPropertyType', SolidArrayPropertyType)


# Complex type {http://www.opengis.net/gml/3.2}ShellPropertyType with content type ELEMENT_ONLY
class ShellPropertyType (pyxb.binding.basis.complexTypeDefinition):
    """A property with the content model of gml:ShellPropertyType encapsulates a shell to represent a component of a solid boundary."""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'ShellPropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 842, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.opengis.net/gml/3.2}Shell uses Python identifier Shell
    __Shell = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'Shell'), 'Shell', '__httpwww_opengis_netgml3_2_ShellPropertyType_httpwww_opengis_netgml3_2Shell', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 829, 1), )

    
    Shell = property(__Shell.value, __Shell.set, None, 'A shell is used to represent a single connected component of a solid boundary as specified in ISO 19107:2003, 6.3.8.\nEvery gml:surfaceMember references or contains one surface, i.e. any element which is substitutable for gml:AbstractSurface. In the context of a shell, the surfaces describe the boundary of the solid. \nIf provided, the aggregationType attribute shall have the value "set".\n')

    _ElementMap.update({
        __Shell.name() : __Shell
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.ShellPropertyType = ShellPropertyType
_Namespace_gml.addCategoryObject('typeBinding', 'ShellPropertyType', ShellPropertyType)


# Complex type {http://www.opengis.net/gml/3.2}AbstractGMLType with content type ELEMENT_ONLY
class AbstractGMLType (pyxb.binding.basis.complexTypeDefinition):
    """Complex type {http://www.opengis.net/gml/3.2}AbstractGMLType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = True
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractGMLType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 31, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.opengis.net/gml/3.2}metaDataProperty uses Python identifier metaDataProperty
    __metaDataProperty = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'metaDataProperty'), 'metaDataProperty', '__httpwww_opengis_netgml3_2_AbstractGMLType_httpwww_opengis_netgml3_2metaDataProperty', True, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 672, 1), )

    
    metaDataProperty = property(__metaDataProperty.value, __metaDataProperty.set, None, '')

    
    # Element {http://www.opengis.net/gml/3.2}description uses Python identifier description
    __description = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'description'), 'description', '__httpwww_opengis_netgml3_2_AbstractGMLType_httpwww_opengis_netgml3_2description', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 117, 1), )

    
    description = property(__description.value, __description.set, None, 'The value of this property is a text description of the object. gml:description uses gml:StringOrRefType as its content model, so it may contain a simple text string content, or carry a reference to an external description. The use of gml:description to reference an external description has been deprecated and replaced by the gml:descriptionReference property.')

    
    # Element {http://www.opengis.net/gml/3.2}descriptionReference uses Python identifier descriptionReference
    __descriptionReference = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'descriptionReference'), 'descriptionReference', '__httpwww_opengis_netgml3_2_AbstractGMLType_httpwww_opengis_netgml3_2descriptionReference', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 122, 1), )

    
    descriptionReference = property(__descriptionReference.value, __descriptionReference.set, None, 'The value of this property is a remote text description of the object. The xlink:href attribute of the gml:descriptionReference property references the external description.')

    
    # Element {http://www.opengis.net/gml/3.2}name uses Python identifier name
    __name = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'name'), 'name', '__httpwww_opengis_netgml3_2_AbstractGMLType_httpwww_opengis_netgml3_2name', True, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 127, 1), )

    
    name = property(__name.value, __name.set, None, 'The gml:name property provides a label or identifier for the object, commonly a descriptive name. An object may have several names, typically assigned by different authorities. gml:name uses the gml:CodeType content model.  The authority for a name is indicated by the value of its (optional) codeSpace attribute.  The name may or may not be unique, as determined by the rules of the organization responsible for the codeSpace.  In common usage there will be one name per authority, so a processing application may select the name from its preferred codeSpace.')

    
    # Element {http://www.opengis.net/gml/3.2}identifier uses Python identifier identifier
    __identifier = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'identifier'), 'identifier', '__httpwww_opengis_netgml3_2_AbstractGMLType_httpwww_opengis_netgml3_2identifier', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 132, 1), )

    
    identifier = property(__identifier.value, __identifier.set, None, 'Often, a special identifier is assigned to an object by the maintaining authority with the intention that it is used in references to the object For such cases, the codeSpace shall be provided. That identifier is usually unique either globally or within an application domain. gml:identifier is a pre-defined property for such identifiers.')

    
    # Attribute {http://www.opengis.net/gml/3.2}id uses Python identifier id
    __id = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gml, 'id'), 'id', '__httpwww_opengis_netgml3_2_AbstractGMLType_httpwww_opengis_netgml3_2id', pyxb.binding.datatypes.ID)
    __id._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 137, 1)
    __id._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 35, 2)
    
    id = property(__id.value, __id.set, None, 'The attribute gml:id supports provision of a handle for the XML element representing a GML Object. Its use is mandatory for all GML objects. It is of XML type ID, so is constrained to be unique in the XML document within which it occurs.')

    _ElementMap.update({
        __metaDataProperty.name() : __metaDataProperty,
        __description.name() : __description,
        __descriptionReference.name() : __descriptionReference,
        __name.name() : __name,
        __identifier.name() : __identifier
    })
    _AttributeMap.update({
        __id.name() : __id
    })
_module_typeBindings.AbstractGMLType = AbstractGMLType
_Namespace_gml.addCategoryObject('typeBinding', 'AbstractGMLType', AbstractGMLType)


# Complex type {http://www.opengis.net/gml/3.2}InlinePropertyType with content type ELEMENT_ONLY
class InlinePropertyType (pyxb.binding.basis.complexTypeDefinition):
    """Complex type {http://www.opengis.net/gml/3.2}InlinePropertyType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'InlinePropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 106, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Attribute owns uses Python identifier owns
    __owns = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'owns'), 'owns', '__httpwww_opengis_netgml3_2_InlinePropertyType_owns', pyxb.binding.datatypes.boolean, unicode_default='false')
    __owns._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 79, 2)
    __owns._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 79, 2)
    
    owns = property(__owns.value, __owns.set, None, None)

    _HasWildcardElement = True
    _ElementMap.update({
        
    })
    _AttributeMap.update({
        __owns.name() : __owns
    })
_module_typeBindings.InlinePropertyType = InlinePropertyType
_Namespace_gml.addCategoryObject('typeBinding', 'InlinePropertyType', InlinePropertyType)


# Complex type {http://www.opengis.net/gml/3.2}AbstractMemberType with content type EMPTY
class AbstractMemberType (pyxb.binding.basis.complexTypeDefinition):
    """To create a collection of GML Objects that are not all features, a property type shall be derived by extension from gml:AbstractMemberType.
This abstract property type is intended to be used only in object types where software shall be able to identify that an instance of such an object type is to be interpreted as a collection of objects.
By default, this abstract property type does not imply any ownership of the objects in the collection. The owns attribute of gml:OwnershipAttributeGroup may be used on a property element instance to assert ownership of an object in the collection. A collection shall not own an object already owned by another object.
"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_EMPTY
    _Abstract = True
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractMemberType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 142, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Attribute owns uses Python identifier owns
    __owns = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'owns'), 'owns', '__httpwww_opengis_netgml3_2_AbstractMemberType_owns', pyxb.binding.datatypes.boolean, unicode_default='false')
    __owns._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 79, 2)
    __owns._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 79, 2)
    
    owns = property(__owns.value, __owns.set, None, None)

    _ElementMap.update({
        
    })
    _AttributeMap.update({
        __owns.name() : __owns
    })
_module_typeBindings.AbstractMemberType = AbstractMemberType
_Namespace_gml.addCategoryObject('typeBinding', 'AbstractMemberType', AbstractMemberType)


# Complex type {http://www.opengis.net/gml/3.2}AbstractMetadataPropertyType with content type EMPTY
class AbstractMetadataPropertyType (pyxb.binding.basis.complexTypeDefinition):
    """To associate metadata described by any XML Schema with a GML object, a property element shall be defined whose content model is derived by extension from gml:AbstractMetadataPropertyType. 
The value of such a property shall be metadata. The content model of such a property type, i.e. the metadata application schema shall be specified by the GML Application Schema.
By default, this abstract property type does not imply any ownership of the metadata. The owns attribute of gml:OwnershipAttributeGroup may be used on a metadata property element instance to assert ownership of the metadata. 
If metadata following the conceptual model of ISO 19115 is to be encoded in a GML document, the corresponding Implementation Specification specified in ISO/TS 19139 shall be used to encode the metadata information.
"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_EMPTY
    _Abstract = True
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractMetadataPropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 170, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Attribute owns uses Python identifier owns
    __owns = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'owns'), 'owns', '__httpwww_opengis_netgml3_2_AbstractMetadataPropertyType_owns', pyxb.binding.datatypes.boolean, unicode_default='false')
    __owns._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 79, 2)
    __owns._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 79, 2)
    
    owns = property(__owns.value, __owns.set, None, None)

    _ElementMap.update({
        
    })
    _AttributeMap.update({
        __owns.name() : __owns
    })
_module_typeBindings.AbstractMetadataPropertyType = AbstractMetadataPropertyType
_Namespace_gml.addCategoryObject('typeBinding', 'AbstractMetadataPropertyType', AbstractMetadataPropertyType)


# Complex type {http://www.opengis.net/gml/3.2}GridLimitsType with content type ELEMENT_ONLY
class GridLimitsType (pyxb.binding.basis.complexTypeDefinition):
    """Complex type {http://www.opengis.net/gml/3.2}GridLimitsType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'GridLimitsType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/grids.xsd', 37, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.opengis.net/gml/3.2}GridEnvelope uses Python identifier GridEnvelope
    __GridEnvelope = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'GridEnvelope'), 'GridEnvelope', '__httpwww_opengis_netgml3_2_GridLimitsType_httpwww_opengis_netgml3_2GridEnvelope', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/grids.xsd', 39, 3), )

    
    GridEnvelope = property(__GridEnvelope.value, __GridEnvelope.set, None, None)

    _ElementMap.update({
        __GridEnvelope.name() : __GridEnvelope
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.GridLimitsType = GridLimitsType
_Namespace_gml.addCategoryObject('typeBinding', 'GridLimitsType', GridLimitsType)


# Complex type {http://www.opengis.net/gml/3.2}GridEnvelopeType with content type ELEMENT_ONLY
class GridEnvelopeType (pyxb.binding.basis.complexTypeDefinition):
    """Complex type {http://www.opengis.net/gml/3.2}GridEnvelopeType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'GridEnvelopeType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/grids.xsd', 42, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.opengis.net/gml/3.2}low uses Python identifier low
    __low = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'low'), 'low', '__httpwww_opengis_netgml3_2_GridEnvelopeType_httpwww_opengis_netgml3_2low', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/grids.xsd', 44, 3), )

    
    low = property(__low.value, __low.set, None, None)

    
    # Element {http://www.opengis.net/gml/3.2}high uses Python identifier high
    __high = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'high'), 'high', '__httpwww_opengis_netgml3_2_GridEnvelopeType_httpwww_opengis_netgml3_2high', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/grids.xsd', 45, 3), )

    
    high = property(__high.value, __high.set, None, None)

    _ElementMap.update({
        __low.name() : __low,
        __high.name() : __high
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.GridEnvelopeType = GridEnvelopeType
_Namespace_gml.addCategoryObject('typeBinding', 'GridEnvelopeType', GridEnvelopeType)


# Complex type {http://www.opengis.net/gml/3.2}TopoPointPropertyType with content type ELEMENT_ONLY
class TopoPointPropertyType (pyxb.binding.basis.complexTypeDefinition):
    """Complex type {http://www.opengis.net/gml/3.2}TopoPointPropertyType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'TopoPointPropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/topology.xsd', 229, 2)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.opengis.net/gml/3.2}TopoPoint uses Python identifier TopoPoint
    __TopoPoint = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'TopoPoint'), 'TopoPoint', '__httpwww_opengis_netgml3_2_TopoPointPropertyType_httpwww_opengis_netgml3_2TopoPoint', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/topology.xsd', 224, 2), )

    
    TopoPoint = property(__TopoPoint.value, __TopoPoint.set, None, 'The intended use of gml:TopoPoint is to appear within a point feature to express the structural and possibly geometric relationships of this feature to other features via shared node definitions.')

    
    # Attribute owns uses Python identifier owns
    __owns = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'owns'), 'owns', '__httpwww_opengis_netgml3_2_TopoPointPropertyType_owns', pyxb.binding.datatypes.boolean, unicode_default='false')
    __owns._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 79, 2)
    __owns._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 79, 2)
    
    owns = property(__owns.value, __owns.set, None, None)

    _ElementMap.update({
        __TopoPoint.name() : __TopoPoint
    })
    _AttributeMap.update({
        __owns.name() : __owns
    })
_module_typeBindings.TopoPointPropertyType = TopoPointPropertyType
_Namespace_gml.addCategoryObject('typeBinding', 'TopoPointPropertyType', TopoPointPropertyType)


# Complex type {http://www.opengis.net/gml/3.2}TopoCurvePropertyType with content type ELEMENT_ONLY
class TopoCurvePropertyType (pyxb.binding.basis.complexTypeDefinition):
    """Complex type {http://www.opengis.net/gml/3.2}TopoCurvePropertyType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'TopoCurvePropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/topology.xsd', 256, 2)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.opengis.net/gml/3.2}TopoCurve uses Python identifier TopoCurve
    __TopoCurve = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'TopoCurve'), 'TopoCurve', '__httpwww_opengis_netgml3_2_TopoCurvePropertyType_httpwww_opengis_netgml3_2TopoCurve', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/topology.xsd', 250, 2), )

    
    TopoCurve = property(__TopoCurve.value, __TopoCurve.set, None, 'gml:TopoCurve represents a homogeneous topological expression, a sequence of directed edges, which if realised are isomorphic to a geometric curve primitive. The intended use of gml:TopoCurve is to appear within a line feature to express the structural and geometric relationships of this feature to other features via the shared edge definitions.\nIf provided, the aggregationType attribute shall have the value "sequence".')

    
    # Attribute owns uses Python identifier owns
    __owns = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'owns'), 'owns', '__httpwww_opengis_netgml3_2_TopoCurvePropertyType_owns', pyxb.binding.datatypes.boolean, unicode_default='false')
    __owns._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 79, 2)
    __owns._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 79, 2)
    
    owns = property(__owns.value, __owns.set, None, None)

    _ElementMap.update({
        __TopoCurve.name() : __TopoCurve
    })
    _AttributeMap.update({
        __owns.name() : __owns
    })
_module_typeBindings.TopoCurvePropertyType = TopoCurvePropertyType
_Namespace_gml.addCategoryObject('typeBinding', 'TopoCurvePropertyType', TopoCurvePropertyType)


# Complex type {http://www.opengis.net/gml/3.2}TopoSurfacePropertyType with content type ELEMENT_ONLY
class TopoSurfacePropertyType (pyxb.binding.basis.complexTypeDefinition):
    """Complex type {http://www.opengis.net/gml/3.2}TopoSurfacePropertyType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'TopoSurfacePropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/topology.xsd', 282, 2)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.opengis.net/gml/3.2}TopoSurface uses Python identifier TopoSurface
    __TopoSurface = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'TopoSurface'), 'TopoSurface', '__httpwww_opengis_netgml3_2_TopoSurfacePropertyType_httpwww_opengis_netgml3_2TopoSurface', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/topology.xsd', 277, 2), )

    
    TopoSurface = property(__TopoSurface.value, __TopoSurface.set, None, 'gml:TopoSurface represents a homogeneous topological expression, a set of directed faces, which if realised are isomorphic to a geometric surface primitive. The intended use of gml:TopoSurface is to appear within a surface feature to express the structural and possibly geometric relationships of this surface feature to other features via the shared face definitions.')

    
    # Attribute owns uses Python identifier owns
    __owns = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'owns'), 'owns', '__httpwww_opengis_netgml3_2_TopoSurfacePropertyType_owns', pyxb.binding.datatypes.boolean, unicode_default='false')
    __owns._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 79, 2)
    __owns._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 79, 2)
    
    owns = property(__owns.value, __owns.set, None, None)

    _ElementMap.update({
        __TopoSurface.name() : __TopoSurface
    })
    _AttributeMap.update({
        __owns.name() : __owns
    })
_module_typeBindings.TopoSurfacePropertyType = TopoSurfacePropertyType
_Namespace_gml.addCategoryObject('typeBinding', 'TopoSurfacePropertyType', TopoSurfacePropertyType)


# Complex type {http://www.opengis.net/gml/3.2}TopoVolumePropertyType with content type ELEMENT_ONLY
class TopoVolumePropertyType (pyxb.binding.basis.complexTypeDefinition):
    """Complex type {http://www.opengis.net/gml/3.2}TopoVolumePropertyType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'TopoVolumePropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/topology.xsd', 308, 2)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.opengis.net/gml/3.2}TopoVolume uses Python identifier TopoVolume
    __TopoVolume = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'TopoVolume'), 'TopoVolume', '__httpwww_opengis_netgml3_2_TopoVolumePropertyType_httpwww_opengis_netgml3_2TopoVolume', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/topology.xsd', 303, 2), )

    
    TopoVolume = property(__TopoVolume.value, __TopoVolume.set, None, 'gml:TopoVolume represents a homogeneous topological expression, a set of directed topologic solids, which if realised are isomorphic to a geometric solid primitive. The intended use of gml:TopoVolume is to appear within a solid feature to express the structural and geometric relationships of this solid feature to other features via the shared solid definitions.')

    
    # Attribute owns uses Python identifier owns
    __owns = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'owns'), 'owns', '__httpwww_opengis_netgml3_2_TopoVolumePropertyType_owns', pyxb.binding.datatypes.boolean, unicode_default='false')
    __owns._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 79, 2)
    __owns._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 79, 2)
    
    owns = property(__owns.value, __owns.set, None, None)

    _ElementMap.update({
        __TopoVolume.name() : __TopoVolume
    })
    _AttributeMap.update({
        __owns.name() : __owns
    })
_module_typeBindings.TopoVolumePropertyType = TopoVolumePropertyType
_Namespace_gml.addCategoryObject('typeBinding', 'TopoVolumePropertyType', TopoVolumePropertyType)


# Complex type {http://www.opengis.net/gml/3.2}TopoPrimitiveArrayAssociationType with content type ELEMENT_ONLY
class TopoPrimitiveArrayAssociationType (pyxb.binding.basis.complexTypeDefinition):
    """Complex type {http://www.opengis.net/gml/3.2}TopoPrimitiveArrayAssociationType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'TopoPrimitiveArrayAssociationType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/topology.xsd', 374, 2)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.opengis.net/gml/3.2}AbstractTopoPrimitive uses Python identifier AbstractTopoPrimitive
    __AbstractTopoPrimitive = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractTopoPrimitive'), 'AbstractTopoPrimitive', '__httpwww_opengis_netgml3_2_TopoPrimitiveArrayAssociationType_httpwww_opengis_netgml3_2AbstractTopoPrimitive', True, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/topology.xsd', 31, 2), )

    
    AbstractTopoPrimitive = property(__AbstractTopoPrimitive.value, __AbstractTopoPrimitive.set, None, 'gml:AbstractTopoPrimitive acts as the base type for all topological primitives. Topology primitives are the atomic (smallest possible) units of a topology complex. \nEach topology primitive may contain references to other topology primitives of codimension 2 or more (gml:isolated). Conversely, nodes may have faces as containers and nodes and edges may have solids as containers (gml:container).')

    
    # Attribute owns uses Python identifier owns
    __owns = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'owns'), 'owns', '__httpwww_opengis_netgml3_2_TopoPrimitiveArrayAssociationType_owns', pyxb.binding.datatypes.boolean, unicode_default='false')
    __owns._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 79, 2)
    __owns._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 79, 2)
    
    owns = property(__owns.value, __owns.set, None, None)

    _ElementMap.update({
        __AbstractTopoPrimitive.name() : __AbstractTopoPrimitive
    })
    _AttributeMap.update({
        __owns.name() : __owns
    })
_module_typeBindings.TopoPrimitiveArrayAssociationType = TopoPrimitiveArrayAssociationType
_Namespace_gml.addCategoryObject('typeBinding', 'TopoPrimitiveArrayAssociationType', TopoPrimitiveArrayAssociationType)


# Complex type {http://www.opengis.net/gml/3.2}FormulaType with content type ELEMENT_ONLY
class FormulaType (pyxb.binding.basis.complexTypeDefinition):
    """Complex type {http://www.opengis.net/gml/3.2}FormulaType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'FormulaType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/units.xsd', 154, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.opengis.net/gml/3.2}a uses Python identifier a
    __a = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'a'), 'a', '__httpwww_opengis_netgml3_2_FormulaType_httpwww_opengis_netgml3_2a', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/units.xsd', 156, 3), )

    
    a = property(__a.value, __a.set, None, None)

    
    # Element {http://www.opengis.net/gml/3.2}b uses Python identifier b
    __b = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'b'), 'b', '__httpwww_opengis_netgml3_2_FormulaType_httpwww_opengis_netgml3_2b', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/units.xsd', 157, 3), )

    
    b = property(__b.value, __b.set, None, None)

    
    # Element {http://www.opengis.net/gml/3.2}c uses Python identifier c
    __c = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'c'), 'c', '__httpwww_opengis_netgml3_2_FormulaType_httpwww_opengis_netgml3_2c', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/units.xsd', 158, 3), )

    
    c = property(__c.value, __c.set, None, None)

    
    # Element {http://www.opengis.net/gml/3.2}d uses Python identifier d
    __d = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'd'), 'd', '__httpwww_opengis_netgml3_2_FormulaType_httpwww_opengis_netgml3_2d', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/units.xsd', 159, 3), )

    
    d = property(__d.value, __d.set, None, None)

    _ElementMap.update({
        __a.name() : __a,
        __b.name() : __b,
        __c.name() : __c,
        __d.name() : __d
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.FormulaType = FormulaType
_Namespace_gml.addCategoryObject('typeBinding', 'FormulaType', FormulaType)


# Complex type {http://www.opengis.net/gml/3.2}ValueArrayPropertyType with content type ELEMENT_ONLY
class ValueArrayPropertyType (pyxb.binding.basis.complexTypeDefinition):
    """Complex type {http://www.opengis.net/gml/3.2}ValueArrayPropertyType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'ValueArrayPropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/valueObjects.xsd', 119, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.opengis.net/gml/3.2}Null uses Python identifier Null
    __Null = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'Null'), 'Null', '__httpwww_opengis_netgml3_2_ValueArrayPropertyType_httpwww_opengis_netgml3_2Null', True, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 13, 1), )

    
    Null = property(__Null.value, __Null.set, None, '')

    
    # Element {http://www.opengis.net/gml/3.2}AbstractGeometry uses Python identifier AbstractGeometry
    __AbstractGeometry = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractGeometry'), 'AbstractGeometry', '__httpwww_opengis_netgml3_2_ValueArrayPropertyType_httpwww_opengis_netgml3_2AbstractGeometry', True, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic0d1d.xsd', 50, 1), )

    
    AbstractGeometry = property(__AbstractGeometry.value, __AbstractGeometry.set, None, 'The AbstractGeometry element is the abstract head of the substitution group for all geometry elements of GML. This includes pre-defined and user-defined geometry elements. Any geometry element shall be a direct or indirect extension/restriction of AbstractGeometryType and shall be directly or indirectly in the substitution group of AbstractGeometry.')

    
    # Element {http://www.opengis.net/gml/3.2}AbstractTimeObject uses Python identifier AbstractTimeObject
    __AbstractTimeObject = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractTimeObject'), 'AbstractTimeObject', '__httpwww_opengis_netgml3_2_ValueArrayPropertyType_httpwww_opengis_netgml3_2AbstractTimeObject', True, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporal.xsd', 18, 1), )

    
    AbstractTimeObject = property(__AbstractTimeObject.value, __AbstractTimeObject.set, None, 'gml:AbstractTimeObject acts as the head of a substitution group for all temporal primitives and complexes.')

    
    # Element {http://www.opengis.net/gml/3.2}AbstractValue uses Python identifier AbstractValue
    __AbstractValue = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractValue'), 'AbstractValue', '__httpwww_opengis_netgml3_2_ValueArrayPropertyType_httpwww_opengis_netgml3_2AbstractValue', True, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/valueObjects.xsd', 70, 1), )

    
    AbstractValue = property(__AbstractValue.value, __AbstractValue.set, None, 'gml:AbstractValue is an abstract element which acts as the head of a substitution group which contains gml:AbstractScalarValue, gml:AbstractScalarValueList, gml:CompositeValue and gml:ValueExtent, and (transitively) the elements in their substitution groups.\nThese elements may be used in an application schema as variables, so that in an XML instance document any member of its substitution group may occur.')

    
    # Attribute owns uses Python identifier owns
    __owns = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'owns'), 'owns', '__httpwww_opengis_netgml3_2_ValueArrayPropertyType_owns', pyxb.binding.datatypes.boolean, unicode_default='false')
    __owns._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 79, 2)
    __owns._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 79, 2)
    
    owns = property(__owns.value, __owns.set, None, None)

    _ElementMap.update({
        __Null.name() : __Null,
        __AbstractGeometry.name() : __AbstractGeometry,
        __AbstractTimeObject.name() : __AbstractTimeObject,
        __AbstractValue.name() : __AbstractValue
    })
    _AttributeMap.update({
        __owns.name() : __owns
    })
_module_typeBindings.ValueArrayPropertyType = ValueArrayPropertyType
_Namespace_gml.addCategoryObject('typeBinding', 'ValueArrayPropertyType', ValueArrayPropertyType)


# Complex type {http://www.isotc211.org/2005/gco}TypeName_Type with content type ELEMENT_ONLY
class TypeName_Type (AbstractObject_Type):
    """A TypeName is a LocalName that references either a recordType or object type in some form of schema. The stored value "aName" is the returned value for the "aName()" operation. This is the types name.  - For parsing from types (or objects) the parsible name normally uses a "." navigation separator, so that it is of the form  [class].[member].[memberOfMember]. ...)"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gco, 'TypeName_Type')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 17, 1)
    _ElementMap = AbstractObject_Type._ElementMap.copy()
    _AttributeMap = AbstractObject_Type._AttributeMap.copy()
    # Base type is AbstractObject_Type
    
    # Element {http://www.isotc211.org/2005/gco}aName uses Python identifier aName
    __aName = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gco, 'aName'), 'aName', '__httpwww_isotc211_org2005gco_TypeName_Type_httpwww_isotc211_org2005gcoaName', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 24, 5), )

    
    aName = property(__aName.value, __aName.set, None, None)

    
    # Attribute id inherited from {http://www.isotc211.org/2005/gco}AbstractObject_Type
    
    # Attribute uuid inherited from {http://www.isotc211.org/2005/gco}AbstractObject_Type
    _ElementMap.update({
        __aName.name() : __aName
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.TypeName_Type = TypeName_Type
_Namespace_gco.addCategoryObject('typeBinding', 'TypeName_Type', TypeName_Type)


# Complex type {http://www.isotc211.org/2005/gco}MemberName_Type with content type ELEMENT_ONLY
class MemberName_Type (AbstractObject_Type):
    """A MemberName is a LocalName that references either an attribute slot in a record or  recordType or an attribute, operation, or association role in an object instance or  type description in some form of schema. The stored value "aName" is the returned value for the "aName()" operation."""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gco, 'MemberName_Type')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 40, 1)
    _ElementMap = AbstractObject_Type._ElementMap.copy()
    _AttributeMap = AbstractObject_Type._AttributeMap.copy()
    # Base type is AbstractObject_Type
    
    # Element {http://www.isotc211.org/2005/gco}aName uses Python identifier aName
    __aName = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gco, 'aName'), 'aName', '__httpwww_isotc211_org2005gco_MemberName_Type_httpwww_isotc211_org2005gcoaName', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 47, 5), )

    
    aName = property(__aName.value, __aName.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gco}attributeType uses Python identifier attributeType
    __attributeType = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gco, 'attributeType'), 'attributeType', '__httpwww_isotc211_org2005gco_MemberName_Type_httpwww_isotc211_org2005gcoattributeType', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 48, 5), )

    
    attributeType = property(__attributeType.value, __attributeType.set, None, None)

    
    # Attribute id inherited from {http://www.isotc211.org/2005/gco}AbstractObject_Type
    
    # Attribute uuid inherited from {http://www.isotc211.org/2005/gco}AbstractObject_Type
    _ElementMap.update({
        __aName.name() : __aName,
        __attributeType.name() : __attributeType
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.MemberName_Type = MemberName_Type
_Namespace_gco.addCategoryObject('typeBinding', 'MemberName_Type', MemberName_Type)


# Complex type {http://www.isotc211.org/2005/gco}Multiplicity_Type with content type ELEMENT_ONLY
class Multiplicity_Type (AbstractObject_Type):
    """Use to represent the possible cardinality of a relation. Represented by a set of simple multiplicity ranges."""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gco, 'Multiplicity_Type')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 64, 1)
    _ElementMap = AbstractObject_Type._ElementMap.copy()
    _AttributeMap = AbstractObject_Type._AttributeMap.copy()
    # Base type is AbstractObject_Type
    
    # Element {http://www.isotc211.org/2005/gco}range uses Python identifier range
    __range = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gco, 'range'), 'range', '__httpwww_isotc211_org2005gco_Multiplicity_Type_httpwww_isotc211_org2005gcorange', True, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 71, 5), )

    
    range = property(__range.value, __range.set, None, None)

    
    # Attribute id inherited from {http://www.isotc211.org/2005/gco}AbstractObject_Type
    
    # Attribute uuid inherited from {http://www.isotc211.org/2005/gco}AbstractObject_Type
    _ElementMap.update({
        __range.name() : __range
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.Multiplicity_Type = Multiplicity_Type
_Namespace_gco.addCategoryObject('typeBinding', 'Multiplicity_Type', Multiplicity_Type)


# Complex type {http://www.isotc211.org/2005/gco}MultiplicityRange_Type with content type ELEMENT_ONLY
class MultiplicityRange_Type (AbstractObject_Type):
    """A component of a multiplicity, consisting of an non-negative lower bound, and a potentially infinite upper bound."""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gco, 'MultiplicityRange_Type')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 87, 1)
    _ElementMap = AbstractObject_Type._ElementMap.copy()
    _AttributeMap = AbstractObject_Type._AttributeMap.copy()
    # Base type is AbstractObject_Type
    
    # Element {http://www.isotc211.org/2005/gco}lower uses Python identifier lower
    __lower = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gco, 'lower'), 'lower', '__httpwww_isotc211_org2005gco_MultiplicityRange_Type_httpwww_isotc211_org2005gcolower', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 94, 5), )

    
    lower = property(__lower.value, __lower.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gco}upper uses Python identifier upper
    __upper = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gco, 'upper'), 'upper', '__httpwww_isotc211_org2005gco_MultiplicityRange_Type_httpwww_isotc211_org2005gcoupper', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 95, 5), )

    
    upper = property(__upper.value, __upper.set, None, None)

    
    # Attribute id inherited from {http://www.isotc211.org/2005/gco}AbstractObject_Type
    
    # Attribute uuid inherited from {http://www.isotc211.org/2005/gco}AbstractObject_Type
    _ElementMap.update({
        __lower.name() : __lower,
        __upper.name() : __upper
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.MultiplicityRange_Type = MultiplicityRange_Type
_Namespace_gco.addCategoryObject('typeBinding', 'MultiplicityRange_Type', MultiplicityRange_Type)


# Complex type {http://www.isotc211.org/2005/gco}RecordType_Type with content type SIMPLE
class RecordType_Type (pyxb.binding.basis.complexTypeDefinition):
    """Complex type {http://www.isotc211.org/2005/gco}RecordType_Type with content type SIMPLE"""
    _TypeDefinition = pyxb.binding.datatypes.string
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_SIMPLE
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gco, 'RecordType_Type')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 392, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.string
    
    # Attribute {http://www.w3.org/1999/xlink}type uses Python identifier type
    __type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'type'), 'type', '__httpwww_isotc211_org2005gco_RecordType_Type_httpwww_w3_org1999xlinktype', _ImportedBinding_bindings_v1411_write__xlink.typeType, fixed=True, unicode_default='simple')
    __type._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 29, 1)
    __type._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 112, 2)
    
    type = property(__type.value, __type.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}href uses Python identifier href
    __href = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'href'), 'href', '__httpwww_isotc211_org2005gco_RecordType_Type_httpwww_w3_org1999xlinkhref', _ImportedBinding_bindings_v1411_write__xlink.hrefType)
    __href._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 42, 1)
    __href._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 113, 2)
    
    href = property(__href.value, __href.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}role uses Python identifier role
    __role = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'role'), 'role', '__httpwww_isotc211_org2005gco_RecordType_Type_httpwww_w3_org1999xlinkrole', _ImportedBinding_bindings_v1411_write__xlink.roleType)
    __role._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 48, 1)
    __role._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 114, 2)
    
    role = property(__role.value, __role.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}arcrole uses Python identifier arcrole
    __arcrole = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'arcrole'), 'arcrole', '__httpwww_isotc211_org2005gco_RecordType_Type_httpwww_w3_org1999xlinkarcrole', _ImportedBinding_bindings_v1411_write__xlink.arcroleType)
    __arcrole._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 56, 1)
    __arcrole._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 115, 2)
    
    arcrole = property(__arcrole.value, __arcrole.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}title uses Python identifier title
    __title = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'title'), 'title', '__httpwww_isotc211_org2005gco_RecordType_Type_httpwww_w3_org1999xlinktitle', _ImportedBinding_bindings_v1411_write__xlink.titleAttrType)
    __title._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 64, 1)
    __title._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 116, 2)
    
    title = property(__title.value, __title.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}show uses Python identifier show
    __show = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'show'), 'show', '__httpwww_isotc211_org2005gco_RecordType_Type_httpwww_w3_org1999xlinkshow', _ImportedBinding_bindings_v1411_write__xlink.showType)
    __show._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 70, 1)
    __show._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 117, 2)
    
    show = property(__show.value, __show.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}actuate uses Python identifier actuate
    __actuate = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'actuate'), 'actuate', '__httpwww_isotc211_org2005gco_RecordType_Type_httpwww_w3_org1999xlinkactuate', _ImportedBinding_bindings_v1411_write__xlink.actuateType)
    __actuate._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 82, 1)
    __actuate._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 118, 2)
    
    actuate = property(__actuate.value, __actuate.set, None, None)

    _ElementMap.update({
        
    })
    _AttributeMap.update({
        __type.name() : __type,
        __href.name() : __href,
        __role.name() : __role,
        __arcrole.name() : __arcrole,
        __title.name() : __title,
        __show.name() : __show,
        __actuate.name() : __actuate
    })
_module_typeBindings.RecordType_Type = RecordType_Type
_Namespace_gco.addCategoryObject('typeBinding', 'RecordType_Type', RecordType_Type)


# Complex type {http://www.isotc211.org/2005/gmd}MD_ApplicationSchemaInformation_Type with content type ELEMENT_ONLY
class MD_ApplicationSchemaInformation_Type (AbstractObject_Type):
    """Information about the application schema used to build the dataset"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_ApplicationSchemaInformation_Type')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/applicationSchema.xsd', 14, 1)
    _ElementMap = AbstractObject_Type._ElementMap.copy()
    _AttributeMap = AbstractObject_Type._AttributeMap.copy()
    # Base type is AbstractObject_Type
    
    # Element {http://www.isotc211.org/2005/gmd}name uses Python identifier name
    __name = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'name'), 'name', '__httpwww_isotc211_org2005gmd_MD_ApplicationSchemaInformation_Type_httpwww_isotc211_org2005gmdname', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/applicationSchema.xsd', 21, 5), )

    
    name = property(__name.value, __name.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}schemaLanguage uses Python identifier schemaLanguage
    __schemaLanguage = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'schemaLanguage'), 'schemaLanguage', '__httpwww_isotc211_org2005gmd_MD_ApplicationSchemaInformation_Type_httpwww_isotc211_org2005gmdschemaLanguage', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/applicationSchema.xsd', 22, 5), )

    
    schemaLanguage = property(__schemaLanguage.value, __schemaLanguage.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}constraintLanguage uses Python identifier constraintLanguage
    __constraintLanguage = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'constraintLanguage'), 'constraintLanguage', '__httpwww_isotc211_org2005gmd_MD_ApplicationSchemaInformation_Type_httpwww_isotc211_org2005gmdconstraintLanguage', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/applicationSchema.xsd', 23, 5), )

    
    constraintLanguage = property(__constraintLanguage.value, __constraintLanguage.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}schemaAscii uses Python identifier schemaAscii
    __schemaAscii = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'schemaAscii'), 'schemaAscii', '__httpwww_isotc211_org2005gmd_MD_ApplicationSchemaInformation_Type_httpwww_isotc211_org2005gmdschemaAscii', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/applicationSchema.xsd', 24, 5), )

    
    schemaAscii = property(__schemaAscii.value, __schemaAscii.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}graphicsFile uses Python identifier graphicsFile
    __graphicsFile = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'graphicsFile'), 'graphicsFile', '__httpwww_isotc211_org2005gmd_MD_ApplicationSchemaInformation_Type_httpwww_isotc211_org2005gmdgraphicsFile', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/applicationSchema.xsd', 25, 5), )

    
    graphicsFile = property(__graphicsFile.value, __graphicsFile.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}softwareDevelopmentFile uses Python identifier softwareDevelopmentFile
    __softwareDevelopmentFile = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'softwareDevelopmentFile'), 'softwareDevelopmentFile', '__httpwww_isotc211_org2005gmd_MD_ApplicationSchemaInformation_Type_httpwww_isotc211_org2005gmdsoftwareDevelopmentFile', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/applicationSchema.xsd', 26, 5), )

    
    softwareDevelopmentFile = property(__softwareDevelopmentFile.value, __softwareDevelopmentFile.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}softwareDevelopmentFileFormat uses Python identifier softwareDevelopmentFileFormat
    __softwareDevelopmentFileFormat = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'softwareDevelopmentFileFormat'), 'softwareDevelopmentFileFormat', '__httpwww_isotc211_org2005gmd_MD_ApplicationSchemaInformation_Type_httpwww_isotc211_org2005gmdsoftwareDevelopmentFileFormat', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/applicationSchema.xsd', 27, 5), )

    
    softwareDevelopmentFileFormat = property(__softwareDevelopmentFileFormat.value, __softwareDevelopmentFileFormat.set, None, None)

    
    # Attribute id inherited from {http://www.isotc211.org/2005/gco}AbstractObject_Type
    
    # Attribute uuid inherited from {http://www.isotc211.org/2005/gco}AbstractObject_Type
    _ElementMap.update({
        __name.name() : __name,
        __schemaLanguage.name() : __schemaLanguage,
        __constraintLanguage.name() : __constraintLanguage,
        __schemaAscii.name() : __schemaAscii,
        __graphicsFile.name() : __graphicsFile,
        __softwareDevelopmentFile.name() : __softwareDevelopmentFile,
        __softwareDevelopmentFileFormat.name() : __softwareDevelopmentFileFormat
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.MD_ApplicationSchemaInformation_Type = MD_ApplicationSchemaInformation_Type
_Namespace_gmd.addCategoryObject('typeBinding', 'MD_ApplicationSchemaInformation_Type', MD_ApplicationSchemaInformation_Type)


# Complex type {http://www.isotc211.org/2005/gmd}CI_ResponsibleParty_Type with content type ELEMENT_ONLY
class CI_ResponsibleParty_Type (AbstractObject_Type):
    """Identification of, and means of communication with, person(s) and organisations associated with the dataset"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'CI_ResponsibleParty_Type')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 14, 1)
    _ElementMap = AbstractObject_Type._ElementMap.copy()
    _AttributeMap = AbstractObject_Type._AttributeMap.copy()
    # Base type is AbstractObject_Type
    
    # Element {http://www.isotc211.org/2005/gmd}individualName uses Python identifier individualName
    __individualName = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'individualName'), 'individualName', '__httpwww_isotc211_org2005gmd_CI_ResponsibleParty_Type_httpwww_isotc211_org2005gmdindividualName', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 21, 5), )

    
    individualName = property(__individualName.value, __individualName.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}organisationName uses Python identifier organisationName
    __organisationName = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'organisationName'), 'organisationName', '__httpwww_isotc211_org2005gmd_CI_ResponsibleParty_Type_httpwww_isotc211_org2005gmdorganisationName', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 22, 5), )

    
    organisationName = property(__organisationName.value, __organisationName.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}positionName uses Python identifier positionName
    __positionName = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'positionName'), 'positionName', '__httpwww_isotc211_org2005gmd_CI_ResponsibleParty_Type_httpwww_isotc211_org2005gmdpositionName', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 23, 5), )

    
    positionName = property(__positionName.value, __positionName.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}contactInfo uses Python identifier contactInfo
    __contactInfo = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'contactInfo'), 'contactInfo', '__httpwww_isotc211_org2005gmd_CI_ResponsibleParty_Type_httpwww_isotc211_org2005gmdcontactInfo', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 24, 5), )

    
    contactInfo = property(__contactInfo.value, __contactInfo.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}role uses Python identifier role
    __role = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'role'), 'role', '__httpwww_isotc211_org2005gmd_CI_ResponsibleParty_Type_httpwww_isotc211_org2005gmdrole', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 25, 5), )

    
    role = property(__role.value, __role.set, None, None)

    
    # Attribute id inherited from {http://www.isotc211.org/2005/gco}AbstractObject_Type
    
    # Attribute uuid inherited from {http://www.isotc211.org/2005/gco}AbstractObject_Type
    _ElementMap.update({
        __individualName.name() : __individualName,
        __organisationName.name() : __organisationName,
        __positionName.name() : __positionName,
        __contactInfo.name() : __contactInfo,
        __role.name() : __role
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.CI_ResponsibleParty_Type = CI_ResponsibleParty_Type
_Namespace_gmd.addCategoryObject('typeBinding', 'CI_ResponsibleParty_Type', CI_ResponsibleParty_Type)


# Complex type {http://www.isotc211.org/2005/gmd}CI_Citation_Type with content type ELEMENT_ONLY
class CI_Citation_Type (AbstractObject_Type):
    """Standardized resource reference"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'CI_Citation_Type')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 41, 1)
    _ElementMap = AbstractObject_Type._ElementMap.copy()
    _AttributeMap = AbstractObject_Type._AttributeMap.copy()
    # Base type is AbstractObject_Type
    
    # Element {http://www.isotc211.org/2005/gmd}title uses Python identifier title
    __title = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'title'), 'title', '__httpwww_isotc211_org2005gmd_CI_Citation_Type_httpwww_isotc211_org2005gmdtitle', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 48, 5), )

    
    title = property(__title.value, __title.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}alternateTitle uses Python identifier alternateTitle
    __alternateTitle = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'alternateTitle'), 'alternateTitle', '__httpwww_isotc211_org2005gmd_CI_Citation_Type_httpwww_isotc211_org2005gmdalternateTitle', True, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 49, 5), )

    
    alternateTitle = property(__alternateTitle.value, __alternateTitle.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}date uses Python identifier date
    __date = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'date'), 'date', '__httpwww_isotc211_org2005gmd_CI_Citation_Type_httpwww_isotc211_org2005gmddate', True, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 50, 5), )

    
    date = property(__date.value, __date.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}edition uses Python identifier edition
    __edition = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'edition'), 'edition', '__httpwww_isotc211_org2005gmd_CI_Citation_Type_httpwww_isotc211_org2005gmdedition', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 51, 5), )

    
    edition = property(__edition.value, __edition.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}editionDate uses Python identifier editionDate
    __editionDate = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'editionDate'), 'editionDate', '__httpwww_isotc211_org2005gmd_CI_Citation_Type_httpwww_isotc211_org2005gmdeditionDate', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 52, 5), )

    
    editionDate = property(__editionDate.value, __editionDate.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}identifier uses Python identifier identifier
    __identifier = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'identifier'), 'identifier', '__httpwww_isotc211_org2005gmd_CI_Citation_Type_httpwww_isotc211_org2005gmdidentifier', True, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 53, 5), )

    
    identifier = property(__identifier.value, __identifier.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}citedResponsibleParty uses Python identifier citedResponsibleParty
    __citedResponsibleParty = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'citedResponsibleParty'), 'citedResponsibleParty', '__httpwww_isotc211_org2005gmd_CI_Citation_Type_httpwww_isotc211_org2005gmdcitedResponsibleParty', True, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 54, 5), )

    
    citedResponsibleParty = property(__citedResponsibleParty.value, __citedResponsibleParty.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}presentationForm uses Python identifier presentationForm
    __presentationForm = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'presentationForm'), 'presentationForm', '__httpwww_isotc211_org2005gmd_CI_Citation_Type_httpwww_isotc211_org2005gmdpresentationForm', True, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 55, 5), )

    
    presentationForm = property(__presentationForm.value, __presentationForm.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}series uses Python identifier series
    __series = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'series'), 'series', '__httpwww_isotc211_org2005gmd_CI_Citation_Type_httpwww_isotc211_org2005gmdseries', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 56, 5), )

    
    series = property(__series.value, __series.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}otherCitationDetails uses Python identifier otherCitationDetails
    __otherCitationDetails = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'otherCitationDetails'), 'otherCitationDetails', '__httpwww_isotc211_org2005gmd_CI_Citation_Type_httpwww_isotc211_org2005gmdotherCitationDetails', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 57, 5), )

    
    otherCitationDetails = property(__otherCitationDetails.value, __otherCitationDetails.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}collectiveTitle uses Python identifier collectiveTitle
    __collectiveTitle = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'collectiveTitle'), 'collectiveTitle', '__httpwww_isotc211_org2005gmd_CI_Citation_Type_httpwww_isotc211_org2005gmdcollectiveTitle', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 58, 5), )

    
    collectiveTitle = property(__collectiveTitle.value, __collectiveTitle.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}ISBN uses Python identifier ISBN
    __ISBN = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'ISBN'), 'ISBN', '__httpwww_isotc211_org2005gmd_CI_Citation_Type_httpwww_isotc211_org2005gmdISBN', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 59, 5), )

    
    ISBN = property(__ISBN.value, __ISBN.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}ISSN uses Python identifier ISSN
    __ISSN = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'ISSN'), 'ISSN', '__httpwww_isotc211_org2005gmd_CI_Citation_Type_httpwww_isotc211_org2005gmdISSN', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 60, 5), )

    
    ISSN = property(__ISSN.value, __ISSN.set, None, None)

    
    # Attribute id inherited from {http://www.isotc211.org/2005/gco}AbstractObject_Type
    
    # Attribute uuid inherited from {http://www.isotc211.org/2005/gco}AbstractObject_Type
    _ElementMap.update({
        __title.name() : __title,
        __alternateTitle.name() : __alternateTitle,
        __date.name() : __date,
        __edition.name() : __edition,
        __editionDate.name() : __editionDate,
        __identifier.name() : __identifier,
        __citedResponsibleParty.name() : __citedResponsibleParty,
        __presentationForm.name() : __presentationForm,
        __series.name() : __series,
        __otherCitationDetails.name() : __otherCitationDetails,
        __collectiveTitle.name() : __collectiveTitle,
        __ISBN.name() : __ISBN,
        __ISSN.name() : __ISSN
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.CI_Citation_Type = CI_Citation_Type
_Namespace_gmd.addCategoryObject('typeBinding', 'CI_Citation_Type', CI_Citation_Type)


# Complex type {http://www.isotc211.org/2005/gmd}CI_Address_Type with content type ELEMENT_ONLY
class CI_Address_Type (AbstractObject_Type):
    """Location of the responsible individual or organisation"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'CI_Address_Type')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 76, 1)
    _ElementMap = AbstractObject_Type._ElementMap.copy()
    _AttributeMap = AbstractObject_Type._AttributeMap.copy()
    # Base type is AbstractObject_Type
    
    # Element {http://www.isotc211.org/2005/gmd}deliveryPoint uses Python identifier deliveryPoint
    __deliveryPoint = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'deliveryPoint'), 'deliveryPoint', '__httpwww_isotc211_org2005gmd_CI_Address_Type_httpwww_isotc211_org2005gmddeliveryPoint', True, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 83, 5), )

    
    deliveryPoint = property(__deliveryPoint.value, __deliveryPoint.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}city uses Python identifier city
    __city = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'city'), 'city', '__httpwww_isotc211_org2005gmd_CI_Address_Type_httpwww_isotc211_org2005gmdcity', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 84, 5), )

    
    city = property(__city.value, __city.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}administrativeArea uses Python identifier administrativeArea
    __administrativeArea = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'administrativeArea'), 'administrativeArea', '__httpwww_isotc211_org2005gmd_CI_Address_Type_httpwww_isotc211_org2005gmdadministrativeArea', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 85, 5), )

    
    administrativeArea = property(__administrativeArea.value, __administrativeArea.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}postalCode uses Python identifier postalCode
    __postalCode = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'postalCode'), 'postalCode', '__httpwww_isotc211_org2005gmd_CI_Address_Type_httpwww_isotc211_org2005gmdpostalCode', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 86, 5), )

    
    postalCode = property(__postalCode.value, __postalCode.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}country uses Python identifier country
    __country = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'country'), 'country', '__httpwww_isotc211_org2005gmd_CI_Address_Type_httpwww_isotc211_org2005gmdcountry', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 87, 5), )

    
    country = property(__country.value, __country.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}electronicMailAddress uses Python identifier electronicMailAddress
    __electronicMailAddress = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'electronicMailAddress'), 'electronicMailAddress', '__httpwww_isotc211_org2005gmd_CI_Address_Type_httpwww_isotc211_org2005gmdelectronicMailAddress', True, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 88, 5), )

    
    electronicMailAddress = property(__electronicMailAddress.value, __electronicMailAddress.set, None, None)

    
    # Attribute id inherited from {http://www.isotc211.org/2005/gco}AbstractObject_Type
    
    # Attribute uuid inherited from {http://www.isotc211.org/2005/gco}AbstractObject_Type
    _ElementMap.update({
        __deliveryPoint.name() : __deliveryPoint,
        __city.name() : __city,
        __administrativeArea.name() : __administrativeArea,
        __postalCode.name() : __postalCode,
        __country.name() : __country,
        __electronicMailAddress.name() : __electronicMailAddress
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.CI_Address_Type = CI_Address_Type
_Namespace_gmd.addCategoryObject('typeBinding', 'CI_Address_Type', CI_Address_Type)


# Complex type {http://www.isotc211.org/2005/gmd}CI_OnlineResource_Type with content type ELEMENT_ONLY
class CI_OnlineResource_Type (AbstractObject_Type):
    """Information about online sources from which the dataset, specification, or community profile name and extended metadata elements can be obtained."""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'CI_OnlineResource_Type')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 104, 1)
    _ElementMap = AbstractObject_Type._ElementMap.copy()
    _AttributeMap = AbstractObject_Type._AttributeMap.copy()
    # Base type is AbstractObject_Type
    
    # Element {http://www.isotc211.org/2005/gmd}linkage uses Python identifier linkage
    __linkage = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'linkage'), 'linkage', '__httpwww_isotc211_org2005gmd_CI_OnlineResource_Type_httpwww_isotc211_org2005gmdlinkage', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 111, 5), )

    
    linkage = property(__linkage.value, __linkage.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}protocol uses Python identifier protocol
    __protocol = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'protocol'), 'protocol', '__httpwww_isotc211_org2005gmd_CI_OnlineResource_Type_httpwww_isotc211_org2005gmdprotocol', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 112, 5), )

    
    protocol = property(__protocol.value, __protocol.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}applicationProfile uses Python identifier applicationProfile
    __applicationProfile = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'applicationProfile'), 'applicationProfile', '__httpwww_isotc211_org2005gmd_CI_OnlineResource_Type_httpwww_isotc211_org2005gmdapplicationProfile', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 113, 5), )

    
    applicationProfile = property(__applicationProfile.value, __applicationProfile.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}name uses Python identifier name
    __name = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'name'), 'name', '__httpwww_isotc211_org2005gmd_CI_OnlineResource_Type_httpwww_isotc211_org2005gmdname', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 114, 5), )

    
    name = property(__name.value, __name.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}description uses Python identifier description
    __description = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'description'), 'description', '__httpwww_isotc211_org2005gmd_CI_OnlineResource_Type_httpwww_isotc211_org2005gmddescription', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 115, 5), )

    
    description = property(__description.value, __description.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}function uses Python identifier function
    __function = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'function'), 'function', '__httpwww_isotc211_org2005gmd_CI_OnlineResource_Type_httpwww_isotc211_org2005gmdfunction', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 116, 5), )

    
    function = property(__function.value, __function.set, None, None)

    
    # Attribute id inherited from {http://www.isotc211.org/2005/gco}AbstractObject_Type
    
    # Attribute uuid inherited from {http://www.isotc211.org/2005/gco}AbstractObject_Type
    _ElementMap.update({
        __linkage.name() : __linkage,
        __protocol.name() : __protocol,
        __applicationProfile.name() : __applicationProfile,
        __name.name() : __name,
        __description.name() : __description,
        __function.name() : __function
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.CI_OnlineResource_Type = CI_OnlineResource_Type
_Namespace_gmd.addCategoryObject('typeBinding', 'CI_OnlineResource_Type', CI_OnlineResource_Type)


# Complex type {http://www.isotc211.org/2005/gmd}CI_Contact_Type with content type ELEMENT_ONLY
class CI_Contact_Type (AbstractObject_Type):
    """Information required enabling contact with the  responsible person and/or organisation"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'CI_Contact_Type')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 132, 1)
    _ElementMap = AbstractObject_Type._ElementMap.copy()
    _AttributeMap = AbstractObject_Type._AttributeMap.copy()
    # Base type is AbstractObject_Type
    
    # Element {http://www.isotc211.org/2005/gmd}phone uses Python identifier phone
    __phone = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'phone'), 'phone', '__httpwww_isotc211_org2005gmd_CI_Contact_Type_httpwww_isotc211_org2005gmdphone', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 139, 5), )

    
    phone = property(__phone.value, __phone.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}address uses Python identifier address
    __address = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'address'), 'address', '__httpwww_isotc211_org2005gmd_CI_Contact_Type_httpwww_isotc211_org2005gmdaddress', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 140, 5), )

    
    address = property(__address.value, __address.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}onlineResource uses Python identifier onlineResource
    __onlineResource = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'onlineResource'), 'onlineResource', '__httpwww_isotc211_org2005gmd_CI_Contact_Type_httpwww_isotc211_org2005gmdonlineResource', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 141, 5), )

    
    onlineResource = property(__onlineResource.value, __onlineResource.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}hoursOfService uses Python identifier hoursOfService
    __hoursOfService = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'hoursOfService'), 'hoursOfService', '__httpwww_isotc211_org2005gmd_CI_Contact_Type_httpwww_isotc211_org2005gmdhoursOfService', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 142, 5), )

    
    hoursOfService = property(__hoursOfService.value, __hoursOfService.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}contactInstructions uses Python identifier contactInstructions
    __contactInstructions = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'contactInstructions'), 'contactInstructions', '__httpwww_isotc211_org2005gmd_CI_Contact_Type_httpwww_isotc211_org2005gmdcontactInstructions', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 143, 5), )

    
    contactInstructions = property(__contactInstructions.value, __contactInstructions.set, None, None)

    
    # Attribute id inherited from {http://www.isotc211.org/2005/gco}AbstractObject_Type
    
    # Attribute uuid inherited from {http://www.isotc211.org/2005/gco}AbstractObject_Type
    _ElementMap.update({
        __phone.name() : __phone,
        __address.name() : __address,
        __onlineResource.name() : __onlineResource,
        __hoursOfService.name() : __hoursOfService,
        __contactInstructions.name() : __contactInstructions
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.CI_Contact_Type = CI_Contact_Type
_Namespace_gmd.addCategoryObject('typeBinding', 'CI_Contact_Type', CI_Contact_Type)


# Complex type {http://www.isotc211.org/2005/gmd}CI_Telephone_Type with content type ELEMENT_ONLY
class CI_Telephone_Type (AbstractObject_Type):
    """Telephone numbers for contacting the responsible individual or organisation"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'CI_Telephone_Type')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 159, 1)
    _ElementMap = AbstractObject_Type._ElementMap.copy()
    _AttributeMap = AbstractObject_Type._AttributeMap.copy()
    # Base type is AbstractObject_Type
    
    # Element {http://www.isotc211.org/2005/gmd}voice uses Python identifier voice
    __voice = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'voice'), 'voice', '__httpwww_isotc211_org2005gmd_CI_Telephone_Type_httpwww_isotc211_org2005gmdvoice', True, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 166, 5), )

    
    voice = property(__voice.value, __voice.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}facsimile uses Python identifier facsimile
    __facsimile = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'facsimile'), 'facsimile', '__httpwww_isotc211_org2005gmd_CI_Telephone_Type_httpwww_isotc211_org2005gmdfacsimile', True, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 167, 5), )

    
    facsimile = property(__facsimile.value, __facsimile.set, None, None)

    
    # Attribute id inherited from {http://www.isotc211.org/2005/gco}AbstractObject_Type
    
    # Attribute uuid inherited from {http://www.isotc211.org/2005/gco}AbstractObject_Type
    _ElementMap.update({
        __voice.name() : __voice,
        __facsimile.name() : __facsimile
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.CI_Telephone_Type = CI_Telephone_Type
_Namespace_gmd.addCategoryObject('typeBinding', 'CI_Telephone_Type', CI_Telephone_Type)


# Complex type {http://www.isotc211.org/2005/gmd}CI_Date_Type with content type ELEMENT_ONLY
class CI_Date_Type (AbstractObject_Type):
    """Complex type {http://www.isotc211.org/2005/gmd}CI_Date_Type with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'CI_Date_Type')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 183, 1)
    _ElementMap = AbstractObject_Type._ElementMap.copy()
    _AttributeMap = AbstractObject_Type._AttributeMap.copy()
    # Base type is AbstractObject_Type
    
    # Element {http://www.isotc211.org/2005/gmd}date uses Python identifier date
    __date = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'date'), 'date', '__httpwww_isotc211_org2005gmd_CI_Date_Type_httpwww_isotc211_org2005gmddate', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 187, 5), )

    
    date = property(__date.value, __date.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}dateType uses Python identifier dateType
    __dateType = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'dateType'), 'dateType', '__httpwww_isotc211_org2005gmd_CI_Date_Type_httpwww_isotc211_org2005gmddateType', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 188, 5), )

    
    dateType = property(__dateType.value, __dateType.set, None, None)

    
    # Attribute id inherited from {http://www.isotc211.org/2005/gco}AbstractObject_Type
    
    # Attribute uuid inherited from {http://www.isotc211.org/2005/gco}AbstractObject_Type
    _ElementMap.update({
        __date.name() : __date,
        __dateType.name() : __dateType
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.CI_Date_Type = CI_Date_Type
_Namespace_gmd.addCategoryObject('typeBinding', 'CI_Date_Type', CI_Date_Type)


# Complex type {http://www.isotc211.org/2005/gmd}CI_Series_Type with content type ELEMENT_ONLY
class CI_Series_Type (AbstractObject_Type):
    """Complex type {http://www.isotc211.org/2005/gmd}CI_Series_Type with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'CI_Series_Type')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 204, 1)
    _ElementMap = AbstractObject_Type._ElementMap.copy()
    _AttributeMap = AbstractObject_Type._AttributeMap.copy()
    # Base type is AbstractObject_Type
    
    # Element {http://www.isotc211.org/2005/gmd}name uses Python identifier name
    __name = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'name'), 'name', '__httpwww_isotc211_org2005gmd_CI_Series_Type_httpwww_isotc211_org2005gmdname', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 208, 5), )

    
    name = property(__name.value, __name.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}issueIdentification uses Python identifier issueIdentification
    __issueIdentification = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'issueIdentification'), 'issueIdentification', '__httpwww_isotc211_org2005gmd_CI_Series_Type_httpwww_isotc211_org2005gmdissueIdentification', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 209, 5), )

    
    issueIdentification = property(__issueIdentification.value, __issueIdentification.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}page uses Python identifier page
    __page = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'page'), 'page', '__httpwww_isotc211_org2005gmd_CI_Series_Type_httpwww_isotc211_org2005gmdpage', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 210, 5), )

    
    page = property(__page.value, __page.set, None, None)

    
    # Attribute id inherited from {http://www.isotc211.org/2005/gco}AbstractObject_Type
    
    # Attribute uuid inherited from {http://www.isotc211.org/2005/gco}AbstractObject_Type
    _ElementMap.update({
        __name.name() : __name,
        __issueIdentification.name() : __issueIdentification,
        __page.name() : __page
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.CI_Series_Type = CI_Series_Type
_Namespace_gmd.addCategoryObject('typeBinding', 'CI_Series_Type', CI_Series_Type)


# Complex type {http://www.isotc211.org/2005/gmd}MD_Constraints_Type with content type ELEMENT_ONLY
class MD_Constraints_Type (AbstractObject_Type):
    """Restrictions on the access and use of a dataset or metadata"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_Constraints_Type')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/constraints.xsd', 13, 1)
    _ElementMap = AbstractObject_Type._ElementMap.copy()
    _AttributeMap = AbstractObject_Type._AttributeMap.copy()
    # Base type is AbstractObject_Type
    
    # Element {http://www.isotc211.org/2005/gmd}useLimitation uses Python identifier useLimitation
    __useLimitation = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'useLimitation'), 'useLimitation', '__httpwww_isotc211_org2005gmd_MD_Constraints_Type_httpwww_isotc211_org2005gmduseLimitation', True, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/constraints.xsd', 20, 5), )

    
    useLimitation = property(__useLimitation.value, __useLimitation.set, None, None)

    
    # Attribute id inherited from {http://www.isotc211.org/2005/gco}AbstractObject_Type
    
    # Attribute uuid inherited from {http://www.isotc211.org/2005/gco}AbstractObject_Type
    _ElementMap.update({
        __useLimitation.name() : __useLimitation
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.MD_Constraints_Type = MD_Constraints_Type
_Namespace_gmd.addCategoryObject('typeBinding', 'MD_Constraints_Type', MD_Constraints_Type)


# Complex type {http://www.isotc211.org/2005/gmd}AbstractMD_ContentInformation_Type with content type EMPTY
class AbstractMD_ContentInformation_Type (AbstractObject_Type):
    """Complex type {http://www.isotc211.org/2005/gmd}AbstractMD_ContentInformation_Type with content type EMPTY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_EMPTY
    _Abstract = True
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'AbstractMD_ContentInformation_Type')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/content.xsd', 101, 1)
    _ElementMap = AbstractObject_Type._ElementMap.copy()
    _AttributeMap = AbstractObject_Type._AttributeMap.copy()
    # Base type is AbstractObject_Type
    
    # Attribute id inherited from {http://www.isotc211.org/2005/gco}AbstractObject_Type
    
    # Attribute uuid inherited from {http://www.isotc211.org/2005/gco}AbstractObject_Type
    _ElementMap.update({
        
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.AbstractMD_ContentInformation_Type = AbstractMD_ContentInformation_Type
_Namespace_gmd.addCategoryObject('typeBinding', 'AbstractMD_ContentInformation_Type', AbstractMD_ContentInformation_Type)


# Complex type {http://www.isotc211.org/2005/gmd}MD_RangeDimension_Type with content type ELEMENT_ONLY
class MD_RangeDimension_Type (AbstractObject_Type):
    """Set of adjacent wavelengths in the electro-magnetic spectrum with a common characteristic, such as the visible band"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_RangeDimension_Type')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/content.xsd', 119, 1)
    _ElementMap = AbstractObject_Type._ElementMap.copy()
    _AttributeMap = AbstractObject_Type._AttributeMap.copy()
    # Base type is AbstractObject_Type
    
    # Element {http://www.isotc211.org/2005/gmd}sequenceIdentifier uses Python identifier sequenceIdentifier
    __sequenceIdentifier = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'sequenceIdentifier'), 'sequenceIdentifier', '__httpwww_isotc211_org2005gmd_MD_RangeDimension_Type_httpwww_isotc211_org2005gmdsequenceIdentifier', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/content.xsd', 126, 5), )

    
    sequenceIdentifier = property(__sequenceIdentifier.value, __sequenceIdentifier.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}descriptor uses Python identifier descriptor
    __descriptor = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'descriptor'), 'descriptor', '__httpwww_isotc211_org2005gmd_MD_RangeDimension_Type_httpwww_isotc211_org2005gmddescriptor', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/content.xsd', 127, 5), )

    
    descriptor = property(__descriptor.value, __descriptor.set, None, None)

    
    # Attribute id inherited from {http://www.isotc211.org/2005/gco}AbstractObject_Type
    
    # Attribute uuid inherited from {http://www.isotc211.org/2005/gco}AbstractObject_Type
    _ElementMap.update({
        __sequenceIdentifier.name() : __sequenceIdentifier,
        __descriptor.name() : __descriptor
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.MD_RangeDimension_Type = MD_RangeDimension_Type
_Namespace_gmd.addCategoryObject('typeBinding', 'MD_RangeDimension_Type', MD_RangeDimension_Type)


# Complex type {http://www.isotc211.org/2005/gmd}LI_ProcessStep_Type with content type ELEMENT_ONLY
class LI_ProcessStep_Type (AbstractObject_Type):
    """Complex type {http://www.isotc211.org/2005/gmd}LI_ProcessStep_Type with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'LI_ProcessStep_Type')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 15, 1)
    _ElementMap = AbstractObject_Type._ElementMap.copy()
    _AttributeMap = AbstractObject_Type._AttributeMap.copy()
    # Base type is AbstractObject_Type
    
    # Element {http://www.isotc211.org/2005/gmd}description uses Python identifier description
    __description = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'description'), 'description', '__httpwww_isotc211_org2005gmd_LI_ProcessStep_Type_httpwww_isotc211_org2005gmddescription', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 19, 5), )

    
    description = property(__description.value, __description.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}rationale uses Python identifier rationale
    __rationale = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'rationale'), 'rationale', '__httpwww_isotc211_org2005gmd_LI_ProcessStep_Type_httpwww_isotc211_org2005gmdrationale', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 20, 5), )

    
    rationale = property(__rationale.value, __rationale.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}dateTime uses Python identifier dateTime
    __dateTime = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'dateTime'), 'dateTime', '__httpwww_isotc211_org2005gmd_LI_ProcessStep_Type_httpwww_isotc211_org2005gmddateTime', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 21, 5), )

    
    dateTime = property(__dateTime.value, __dateTime.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}processor uses Python identifier processor
    __processor = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'processor'), 'processor', '__httpwww_isotc211_org2005gmd_LI_ProcessStep_Type_httpwww_isotc211_org2005gmdprocessor', True, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 22, 5), )

    
    processor = property(__processor.value, __processor.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}source uses Python identifier source
    __source = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'source'), 'source', '__httpwww_isotc211_org2005gmd_LI_ProcessStep_Type_httpwww_isotc211_org2005gmdsource', True, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 23, 5), )

    
    source = property(__source.value, __source.set, None, None)

    
    # Attribute id inherited from {http://www.isotc211.org/2005/gco}AbstractObject_Type
    
    # Attribute uuid inherited from {http://www.isotc211.org/2005/gco}AbstractObject_Type
    _ElementMap.update({
        __description.name() : __description,
        __rationale.name() : __rationale,
        __dateTime.name() : __dateTime,
        __processor.name() : __processor,
        __source.name() : __source
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.LI_ProcessStep_Type = LI_ProcessStep_Type
_Namespace_gmd.addCategoryObject('typeBinding', 'LI_ProcessStep_Type', LI_ProcessStep_Type)


# Complex type {http://www.isotc211.org/2005/gmd}LI_Source_Type with content type ELEMENT_ONLY
class LI_Source_Type (AbstractObject_Type):
    """Complex type {http://www.isotc211.org/2005/gmd}LI_Source_Type with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'LI_Source_Type')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 39, 1)
    _ElementMap = AbstractObject_Type._ElementMap.copy()
    _AttributeMap = AbstractObject_Type._AttributeMap.copy()
    # Base type is AbstractObject_Type
    
    # Element {http://www.isotc211.org/2005/gmd}description uses Python identifier description
    __description = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'description'), 'description', '__httpwww_isotc211_org2005gmd_LI_Source_Type_httpwww_isotc211_org2005gmddescription', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 43, 5), )

    
    description = property(__description.value, __description.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}scaleDenominator uses Python identifier scaleDenominator
    __scaleDenominator = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'scaleDenominator'), 'scaleDenominator', '__httpwww_isotc211_org2005gmd_LI_Source_Type_httpwww_isotc211_org2005gmdscaleDenominator', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 44, 5), )

    
    scaleDenominator = property(__scaleDenominator.value, __scaleDenominator.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}sourceReferenceSystem uses Python identifier sourceReferenceSystem
    __sourceReferenceSystem = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'sourceReferenceSystem'), 'sourceReferenceSystem', '__httpwww_isotc211_org2005gmd_LI_Source_Type_httpwww_isotc211_org2005gmdsourceReferenceSystem', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 45, 5), )

    
    sourceReferenceSystem = property(__sourceReferenceSystem.value, __sourceReferenceSystem.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}sourceCitation uses Python identifier sourceCitation
    __sourceCitation = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'sourceCitation'), 'sourceCitation', '__httpwww_isotc211_org2005gmd_LI_Source_Type_httpwww_isotc211_org2005gmdsourceCitation', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 46, 5), )

    
    sourceCitation = property(__sourceCitation.value, __sourceCitation.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}sourceExtent uses Python identifier sourceExtent
    __sourceExtent = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'sourceExtent'), 'sourceExtent', '__httpwww_isotc211_org2005gmd_LI_Source_Type_httpwww_isotc211_org2005gmdsourceExtent', True, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 47, 5), )

    
    sourceExtent = property(__sourceExtent.value, __sourceExtent.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}sourceStep uses Python identifier sourceStep
    __sourceStep = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'sourceStep'), 'sourceStep', '__httpwww_isotc211_org2005gmd_LI_Source_Type_httpwww_isotc211_org2005gmdsourceStep', True, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 48, 5), )

    
    sourceStep = property(__sourceStep.value, __sourceStep.set, None, None)

    
    # Attribute id inherited from {http://www.isotc211.org/2005/gco}AbstractObject_Type
    
    # Attribute uuid inherited from {http://www.isotc211.org/2005/gco}AbstractObject_Type
    _ElementMap.update({
        __description.name() : __description,
        __scaleDenominator.name() : __scaleDenominator,
        __sourceReferenceSystem.name() : __sourceReferenceSystem,
        __sourceCitation.name() : __sourceCitation,
        __sourceExtent.name() : __sourceExtent,
        __sourceStep.name() : __sourceStep
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.LI_Source_Type = LI_Source_Type
_Namespace_gmd.addCategoryObject('typeBinding', 'LI_Source_Type', LI_Source_Type)


# Complex type {http://www.isotc211.org/2005/gmd}LI_Lineage_Type with content type ELEMENT_ONLY
class LI_Lineage_Type (AbstractObject_Type):
    """Complex type {http://www.isotc211.org/2005/gmd}LI_Lineage_Type with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'LI_Lineage_Type')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 64, 1)
    _ElementMap = AbstractObject_Type._ElementMap.copy()
    _AttributeMap = AbstractObject_Type._AttributeMap.copy()
    # Base type is AbstractObject_Type
    
    # Element {http://www.isotc211.org/2005/gmd}statement uses Python identifier statement
    __statement = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'statement'), 'statement', '__httpwww_isotc211_org2005gmd_LI_Lineage_Type_httpwww_isotc211_org2005gmdstatement', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 68, 5), )

    
    statement = property(__statement.value, __statement.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}processStep uses Python identifier processStep
    __processStep = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'processStep'), 'processStep', '__httpwww_isotc211_org2005gmd_LI_Lineage_Type_httpwww_isotc211_org2005gmdprocessStep', True, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 69, 5), )

    
    processStep = property(__processStep.value, __processStep.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}source uses Python identifier source
    __source = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'source'), 'source', '__httpwww_isotc211_org2005gmd_LI_Lineage_Type_httpwww_isotc211_org2005gmdsource', True, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 70, 5), )

    
    source = property(__source.value, __source.set, None, None)

    
    # Attribute id inherited from {http://www.isotc211.org/2005/gco}AbstractObject_Type
    
    # Attribute uuid inherited from {http://www.isotc211.org/2005/gco}AbstractObject_Type
    _ElementMap.update({
        __statement.name() : __statement,
        __processStep.name() : __processStep,
        __source.name() : __source
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.LI_Lineage_Type = LI_Lineage_Type
_Namespace_gmd.addCategoryObject('typeBinding', 'LI_Lineage_Type', LI_Lineage_Type)


# Complex type {http://www.isotc211.org/2005/gmd}AbstractDQ_Result_Type with content type EMPTY
class AbstractDQ_Result_Type (AbstractObject_Type):
    """Complex type {http://www.isotc211.org/2005/gmd}AbstractDQ_Result_Type with content type EMPTY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_EMPTY
    _Abstract = True
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'AbstractDQ_Result_Type')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 137, 1)
    _ElementMap = AbstractObject_Type._ElementMap.copy()
    _AttributeMap = AbstractObject_Type._AttributeMap.copy()
    # Base type is AbstractObject_Type
    
    # Attribute id inherited from {http://www.isotc211.org/2005/gco}AbstractObject_Type
    
    # Attribute uuid inherited from {http://www.isotc211.org/2005/gco}AbstractObject_Type
    _ElementMap.update({
        
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.AbstractDQ_Result_Type = AbstractDQ_Result_Type
_Namespace_gmd.addCategoryObject('typeBinding', 'AbstractDQ_Result_Type', AbstractDQ_Result_Type)


# Complex type {http://www.isotc211.org/2005/gmd}AbstractDQ_Element_Type with content type ELEMENT_ONLY
class AbstractDQ_Element_Type (AbstractObject_Type):
    """Complex type {http://www.isotc211.org/2005/gmd}AbstractDQ_Element_Type with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = True
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'AbstractDQ_Element_Type')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 475, 1)
    _ElementMap = AbstractObject_Type._ElementMap.copy()
    _AttributeMap = AbstractObject_Type._AttributeMap.copy()
    # Base type is AbstractObject_Type
    
    # Element {http://www.isotc211.org/2005/gmd}nameOfMeasure uses Python identifier nameOfMeasure
    __nameOfMeasure = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'nameOfMeasure'), 'nameOfMeasure', '__httpwww_isotc211_org2005gmd_AbstractDQ_Element_Type_httpwww_isotc211_org2005gmdnameOfMeasure', True, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 479, 5), )

    
    nameOfMeasure = property(__nameOfMeasure.value, __nameOfMeasure.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}measureIdentification uses Python identifier measureIdentification
    __measureIdentification = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'measureIdentification'), 'measureIdentification', '__httpwww_isotc211_org2005gmd_AbstractDQ_Element_Type_httpwww_isotc211_org2005gmdmeasureIdentification', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 480, 5), )

    
    measureIdentification = property(__measureIdentification.value, __measureIdentification.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}measureDescription uses Python identifier measureDescription
    __measureDescription = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'measureDescription'), 'measureDescription', '__httpwww_isotc211_org2005gmd_AbstractDQ_Element_Type_httpwww_isotc211_org2005gmdmeasureDescription', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 481, 5), )

    
    measureDescription = property(__measureDescription.value, __measureDescription.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}evaluationMethodType uses Python identifier evaluationMethodType
    __evaluationMethodType = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'evaluationMethodType'), 'evaluationMethodType', '__httpwww_isotc211_org2005gmd_AbstractDQ_Element_Type_httpwww_isotc211_org2005gmdevaluationMethodType', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 482, 5), )

    
    evaluationMethodType = property(__evaluationMethodType.value, __evaluationMethodType.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}evaluationMethodDescription uses Python identifier evaluationMethodDescription
    __evaluationMethodDescription = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'evaluationMethodDescription'), 'evaluationMethodDescription', '__httpwww_isotc211_org2005gmd_AbstractDQ_Element_Type_httpwww_isotc211_org2005gmdevaluationMethodDescription', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 483, 5), )

    
    evaluationMethodDescription = property(__evaluationMethodDescription.value, __evaluationMethodDescription.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}evaluationProcedure uses Python identifier evaluationProcedure
    __evaluationProcedure = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'evaluationProcedure'), 'evaluationProcedure', '__httpwww_isotc211_org2005gmd_AbstractDQ_Element_Type_httpwww_isotc211_org2005gmdevaluationProcedure', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 484, 5), )

    
    evaluationProcedure = property(__evaluationProcedure.value, __evaluationProcedure.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}dateTime uses Python identifier dateTime
    __dateTime = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'dateTime'), 'dateTime', '__httpwww_isotc211_org2005gmd_AbstractDQ_Element_Type_httpwww_isotc211_org2005gmddateTime', True, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 485, 5), )

    
    dateTime = property(__dateTime.value, __dateTime.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}result uses Python identifier result
    __result = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'result'), 'result', '__httpwww_isotc211_org2005gmd_AbstractDQ_Element_Type_httpwww_isotc211_org2005gmdresult', True, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 486, 5), )

    
    result = property(__result.value, __result.set, None, None)

    
    # Attribute id inherited from {http://www.isotc211.org/2005/gco}AbstractObject_Type
    
    # Attribute uuid inherited from {http://www.isotc211.org/2005/gco}AbstractObject_Type
    _ElementMap.update({
        __nameOfMeasure.name() : __nameOfMeasure,
        __measureIdentification.name() : __measureIdentification,
        __measureDescription.name() : __measureDescription,
        __evaluationMethodType.name() : __evaluationMethodType,
        __evaluationMethodDescription.name() : __evaluationMethodDescription,
        __evaluationProcedure.name() : __evaluationProcedure,
        __dateTime.name() : __dateTime,
        __result.name() : __result
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.AbstractDQ_Element_Type = AbstractDQ_Element_Type
_Namespace_gmd.addCategoryObject('typeBinding', 'AbstractDQ_Element_Type', AbstractDQ_Element_Type)


# Complex type {http://www.isotc211.org/2005/gmd}DQ_DataQuality_Type with content type ELEMENT_ONLY
class DQ_DataQuality_Type (AbstractObject_Type):
    """Complex type {http://www.isotc211.org/2005/gmd}DQ_DataQuality_Type with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'DQ_DataQuality_Type')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 502, 1)
    _ElementMap = AbstractObject_Type._ElementMap.copy()
    _AttributeMap = AbstractObject_Type._AttributeMap.copy()
    # Base type is AbstractObject_Type
    
    # Element {http://www.isotc211.org/2005/gmd}scope uses Python identifier scope
    __scope = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'scope'), 'scope', '__httpwww_isotc211_org2005gmd_DQ_DataQuality_Type_httpwww_isotc211_org2005gmdscope', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 506, 5), )

    
    scope = property(__scope.value, __scope.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}report uses Python identifier report
    __report = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'report'), 'report', '__httpwww_isotc211_org2005gmd_DQ_DataQuality_Type_httpwww_isotc211_org2005gmdreport', True, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 507, 5), )

    
    report = property(__report.value, __report.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}lineage uses Python identifier lineage
    __lineage = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'lineage'), 'lineage', '__httpwww_isotc211_org2005gmd_DQ_DataQuality_Type_httpwww_isotc211_org2005gmdlineage', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 508, 5), )

    
    lineage = property(__lineage.value, __lineage.set, None, None)

    
    # Attribute id inherited from {http://www.isotc211.org/2005/gco}AbstractObject_Type
    
    # Attribute uuid inherited from {http://www.isotc211.org/2005/gco}AbstractObject_Type
    _ElementMap.update({
        __scope.name() : __scope,
        __report.name() : __report,
        __lineage.name() : __lineage
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.DQ_DataQuality_Type = DQ_DataQuality_Type
_Namespace_gmd.addCategoryObject('typeBinding', 'DQ_DataQuality_Type', DQ_DataQuality_Type)


# Complex type {http://www.isotc211.org/2005/gmd}DQ_Scope_Type with content type ELEMENT_ONLY
class DQ_Scope_Type (AbstractObject_Type):
    """Complex type {http://www.isotc211.org/2005/gmd}DQ_Scope_Type with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'DQ_Scope_Type')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 524, 1)
    _ElementMap = AbstractObject_Type._ElementMap.copy()
    _AttributeMap = AbstractObject_Type._AttributeMap.copy()
    # Base type is AbstractObject_Type
    
    # Element {http://www.isotc211.org/2005/gmd}level uses Python identifier level
    __level = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'level'), 'level', '__httpwww_isotc211_org2005gmd_DQ_Scope_Type_httpwww_isotc211_org2005gmdlevel', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 528, 5), )

    
    level = property(__level.value, __level.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}extent uses Python identifier extent
    __extent = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'extent'), 'extent', '__httpwww_isotc211_org2005gmd_DQ_Scope_Type_httpwww_isotc211_org2005gmdextent', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 529, 5), )

    
    extent = property(__extent.value, __extent.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}levelDescription uses Python identifier levelDescription
    __levelDescription = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'levelDescription'), 'levelDescription', '__httpwww_isotc211_org2005gmd_DQ_Scope_Type_httpwww_isotc211_org2005gmdlevelDescription', True, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 530, 5), )

    
    levelDescription = property(__levelDescription.value, __levelDescription.set, None, None)

    
    # Attribute id inherited from {http://www.isotc211.org/2005/gco}AbstractObject_Type
    
    # Attribute uuid inherited from {http://www.isotc211.org/2005/gco}AbstractObject_Type
    _ElementMap.update({
        __level.name() : __level,
        __extent.name() : __extent,
        __levelDescription.name() : __levelDescription
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.DQ_Scope_Type = DQ_Scope_Type
_Namespace_gmd.addCategoryObject('typeBinding', 'DQ_Scope_Type', DQ_Scope_Type)


# Complex type {http://www.isotc211.org/2005/gmd}MD_Medium_Type with content type ELEMENT_ONLY
class MD_Medium_Type (AbstractObject_Type):
    """Information about the media on which the data can be distributed"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_Medium_Type')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/distribution.xsd', 14, 1)
    _ElementMap = AbstractObject_Type._ElementMap.copy()
    _AttributeMap = AbstractObject_Type._AttributeMap.copy()
    # Base type is AbstractObject_Type
    
    # Element {http://www.isotc211.org/2005/gmd}name uses Python identifier name
    __name = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'name'), 'name', '__httpwww_isotc211_org2005gmd_MD_Medium_Type_httpwww_isotc211_org2005gmdname', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/distribution.xsd', 21, 5), )

    
    name = property(__name.value, __name.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}density uses Python identifier density
    __density = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'density'), 'density', '__httpwww_isotc211_org2005gmd_MD_Medium_Type_httpwww_isotc211_org2005gmddensity', True, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/distribution.xsd', 22, 5), )

    
    density = property(__density.value, __density.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}densityUnits uses Python identifier densityUnits
    __densityUnits = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'densityUnits'), 'densityUnits', '__httpwww_isotc211_org2005gmd_MD_Medium_Type_httpwww_isotc211_org2005gmddensityUnits', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/distribution.xsd', 23, 5), )

    
    densityUnits = property(__densityUnits.value, __densityUnits.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}volumes uses Python identifier volumes
    __volumes = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'volumes'), 'volumes', '__httpwww_isotc211_org2005gmd_MD_Medium_Type_httpwww_isotc211_org2005gmdvolumes', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/distribution.xsd', 24, 5), )

    
    volumes = property(__volumes.value, __volumes.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}mediumFormat uses Python identifier mediumFormat
    __mediumFormat = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'mediumFormat'), 'mediumFormat', '__httpwww_isotc211_org2005gmd_MD_Medium_Type_httpwww_isotc211_org2005gmdmediumFormat', True, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/distribution.xsd', 25, 5), )

    
    mediumFormat = property(__mediumFormat.value, __mediumFormat.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}mediumNote uses Python identifier mediumNote
    __mediumNote = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'mediumNote'), 'mediumNote', '__httpwww_isotc211_org2005gmd_MD_Medium_Type_httpwww_isotc211_org2005gmdmediumNote', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/distribution.xsd', 26, 5), )

    
    mediumNote = property(__mediumNote.value, __mediumNote.set, None, None)

    
    # Attribute id inherited from {http://www.isotc211.org/2005/gco}AbstractObject_Type
    
    # Attribute uuid inherited from {http://www.isotc211.org/2005/gco}AbstractObject_Type
    _ElementMap.update({
        __name.name() : __name,
        __density.name() : __density,
        __densityUnits.name() : __densityUnits,
        __volumes.name() : __volumes,
        __mediumFormat.name() : __mediumFormat,
        __mediumNote.name() : __mediumNote
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.MD_Medium_Type = MD_Medium_Type
_Namespace_gmd.addCategoryObject('typeBinding', 'MD_Medium_Type', MD_Medium_Type)


# Complex type {http://www.isotc211.org/2005/gmd}MD_DigitalTransferOptions_Type with content type ELEMENT_ONLY
class MD_DigitalTransferOptions_Type (AbstractObject_Type):
    """Technical means and media by which a dataset is obtained from the distributor"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_DigitalTransferOptions_Type')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/distribution.xsd', 42, 1)
    _ElementMap = AbstractObject_Type._ElementMap.copy()
    _AttributeMap = AbstractObject_Type._AttributeMap.copy()
    # Base type is AbstractObject_Type
    
    # Element {http://www.isotc211.org/2005/gmd}unitsOfDistribution uses Python identifier unitsOfDistribution
    __unitsOfDistribution = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'unitsOfDistribution'), 'unitsOfDistribution', '__httpwww_isotc211_org2005gmd_MD_DigitalTransferOptions_Type_httpwww_isotc211_org2005gmdunitsOfDistribution', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/distribution.xsd', 49, 5), )

    
    unitsOfDistribution = property(__unitsOfDistribution.value, __unitsOfDistribution.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}transferSize uses Python identifier transferSize
    __transferSize = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'transferSize'), 'transferSize', '__httpwww_isotc211_org2005gmd_MD_DigitalTransferOptions_Type_httpwww_isotc211_org2005gmdtransferSize', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/distribution.xsd', 50, 5), )

    
    transferSize = property(__transferSize.value, __transferSize.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}onLine uses Python identifier onLine
    __onLine = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'onLine'), 'onLine', '__httpwww_isotc211_org2005gmd_MD_DigitalTransferOptions_Type_httpwww_isotc211_org2005gmdonLine', True, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/distribution.xsd', 51, 5), )

    
    onLine = property(__onLine.value, __onLine.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}offLine uses Python identifier offLine
    __offLine = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'offLine'), 'offLine', '__httpwww_isotc211_org2005gmd_MD_DigitalTransferOptions_Type_httpwww_isotc211_org2005gmdoffLine', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/distribution.xsd', 52, 5), )

    
    offLine = property(__offLine.value, __offLine.set, None, None)

    
    # Attribute id inherited from {http://www.isotc211.org/2005/gco}AbstractObject_Type
    
    # Attribute uuid inherited from {http://www.isotc211.org/2005/gco}AbstractObject_Type
    _ElementMap.update({
        __unitsOfDistribution.name() : __unitsOfDistribution,
        __transferSize.name() : __transferSize,
        __onLine.name() : __onLine,
        __offLine.name() : __offLine
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.MD_DigitalTransferOptions_Type = MD_DigitalTransferOptions_Type
_Namespace_gmd.addCategoryObject('typeBinding', 'MD_DigitalTransferOptions_Type', MD_DigitalTransferOptions_Type)


# Complex type {http://www.isotc211.org/2005/gmd}MD_StandardOrderProcess_Type with content type ELEMENT_ONLY
class MD_StandardOrderProcess_Type (AbstractObject_Type):
    """Common ways in which the dataset may be obtained or received, and related instructions and fee information"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_StandardOrderProcess_Type')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/distribution.xsd', 68, 1)
    _ElementMap = AbstractObject_Type._ElementMap.copy()
    _AttributeMap = AbstractObject_Type._AttributeMap.copy()
    # Base type is AbstractObject_Type
    
    # Element {http://www.isotc211.org/2005/gmd}fees uses Python identifier fees
    __fees = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'fees'), 'fees', '__httpwww_isotc211_org2005gmd_MD_StandardOrderProcess_Type_httpwww_isotc211_org2005gmdfees', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/distribution.xsd', 75, 5), )

    
    fees = property(__fees.value, __fees.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}plannedAvailableDateTime uses Python identifier plannedAvailableDateTime
    __plannedAvailableDateTime = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'plannedAvailableDateTime'), 'plannedAvailableDateTime', '__httpwww_isotc211_org2005gmd_MD_StandardOrderProcess_Type_httpwww_isotc211_org2005gmdplannedAvailableDateTime', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/distribution.xsd', 76, 5), )

    
    plannedAvailableDateTime = property(__plannedAvailableDateTime.value, __plannedAvailableDateTime.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}orderingInstructions uses Python identifier orderingInstructions
    __orderingInstructions = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'orderingInstructions'), 'orderingInstructions', '__httpwww_isotc211_org2005gmd_MD_StandardOrderProcess_Type_httpwww_isotc211_org2005gmdorderingInstructions', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/distribution.xsd', 77, 5), )

    
    orderingInstructions = property(__orderingInstructions.value, __orderingInstructions.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}turnaround uses Python identifier turnaround
    __turnaround = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'turnaround'), 'turnaround', '__httpwww_isotc211_org2005gmd_MD_StandardOrderProcess_Type_httpwww_isotc211_org2005gmdturnaround', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/distribution.xsd', 78, 5), )

    
    turnaround = property(__turnaround.value, __turnaround.set, None, None)

    
    # Attribute id inherited from {http://www.isotc211.org/2005/gco}AbstractObject_Type
    
    # Attribute uuid inherited from {http://www.isotc211.org/2005/gco}AbstractObject_Type
    _ElementMap.update({
        __fees.name() : __fees,
        __plannedAvailableDateTime.name() : __plannedAvailableDateTime,
        __orderingInstructions.name() : __orderingInstructions,
        __turnaround.name() : __turnaround
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.MD_StandardOrderProcess_Type = MD_StandardOrderProcess_Type
_Namespace_gmd.addCategoryObject('typeBinding', 'MD_StandardOrderProcess_Type', MD_StandardOrderProcess_Type)


# Complex type {http://www.isotc211.org/2005/gmd}MD_Distributor_Type with content type ELEMENT_ONLY
class MD_Distributor_Type (AbstractObject_Type):
    """Information about the distributor"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_Distributor_Type')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/distribution.xsd', 94, 1)
    _ElementMap = AbstractObject_Type._ElementMap.copy()
    _AttributeMap = AbstractObject_Type._AttributeMap.copy()
    # Base type is AbstractObject_Type
    
    # Element {http://www.isotc211.org/2005/gmd}distributorContact uses Python identifier distributorContact
    __distributorContact = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'distributorContact'), 'distributorContact', '__httpwww_isotc211_org2005gmd_MD_Distributor_Type_httpwww_isotc211_org2005gmddistributorContact', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/distribution.xsd', 101, 5), )

    
    distributorContact = property(__distributorContact.value, __distributorContact.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}distributionOrderProcess uses Python identifier distributionOrderProcess
    __distributionOrderProcess = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'distributionOrderProcess'), 'distributionOrderProcess', '__httpwww_isotc211_org2005gmd_MD_Distributor_Type_httpwww_isotc211_org2005gmddistributionOrderProcess', True, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/distribution.xsd', 102, 5), )

    
    distributionOrderProcess = property(__distributionOrderProcess.value, __distributionOrderProcess.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}distributorFormat uses Python identifier distributorFormat
    __distributorFormat = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'distributorFormat'), 'distributorFormat', '__httpwww_isotc211_org2005gmd_MD_Distributor_Type_httpwww_isotc211_org2005gmddistributorFormat', True, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/distribution.xsd', 103, 5), )

    
    distributorFormat = property(__distributorFormat.value, __distributorFormat.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}distributorTransferOptions uses Python identifier distributorTransferOptions
    __distributorTransferOptions = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'distributorTransferOptions'), 'distributorTransferOptions', '__httpwww_isotc211_org2005gmd_MD_Distributor_Type_httpwww_isotc211_org2005gmddistributorTransferOptions', True, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/distribution.xsd', 104, 5), )

    
    distributorTransferOptions = property(__distributorTransferOptions.value, __distributorTransferOptions.set, None, None)

    
    # Attribute id inherited from {http://www.isotc211.org/2005/gco}AbstractObject_Type
    
    # Attribute uuid inherited from {http://www.isotc211.org/2005/gco}AbstractObject_Type
    _ElementMap.update({
        __distributorContact.name() : __distributorContact,
        __distributionOrderProcess.name() : __distributionOrderProcess,
        __distributorFormat.name() : __distributorFormat,
        __distributorTransferOptions.name() : __distributorTransferOptions
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.MD_Distributor_Type = MD_Distributor_Type
_Namespace_gmd.addCategoryObject('typeBinding', 'MD_Distributor_Type', MD_Distributor_Type)


# Complex type {http://www.isotc211.org/2005/gmd}MD_Distribution_Type with content type ELEMENT_ONLY
class MD_Distribution_Type (AbstractObject_Type):
    """Information about the distributor of and options for obtaining the dataset"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_Distribution_Type')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/distribution.xsd', 120, 1)
    _ElementMap = AbstractObject_Type._ElementMap.copy()
    _AttributeMap = AbstractObject_Type._AttributeMap.copy()
    # Base type is AbstractObject_Type
    
    # Element {http://www.isotc211.org/2005/gmd}distributionFormat uses Python identifier distributionFormat
    __distributionFormat = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'distributionFormat'), 'distributionFormat', '__httpwww_isotc211_org2005gmd_MD_Distribution_Type_httpwww_isotc211_org2005gmddistributionFormat', True, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/distribution.xsd', 127, 5), )

    
    distributionFormat = property(__distributionFormat.value, __distributionFormat.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}distributor uses Python identifier distributor
    __distributor = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'distributor'), 'distributor', '__httpwww_isotc211_org2005gmd_MD_Distribution_Type_httpwww_isotc211_org2005gmddistributor', True, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/distribution.xsd', 128, 5), )

    
    distributor = property(__distributor.value, __distributor.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}transferOptions uses Python identifier transferOptions
    __transferOptions = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'transferOptions'), 'transferOptions', '__httpwww_isotc211_org2005gmd_MD_Distribution_Type_httpwww_isotc211_org2005gmdtransferOptions', True, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/distribution.xsd', 129, 5), )

    
    transferOptions = property(__transferOptions.value, __transferOptions.set, None, None)

    
    # Attribute id inherited from {http://www.isotc211.org/2005/gco}AbstractObject_Type
    
    # Attribute uuid inherited from {http://www.isotc211.org/2005/gco}AbstractObject_Type
    _ElementMap.update({
        __distributionFormat.name() : __distributionFormat,
        __distributor.name() : __distributor,
        __transferOptions.name() : __transferOptions
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.MD_Distribution_Type = MD_Distribution_Type
_Namespace_gmd.addCategoryObject('typeBinding', 'MD_Distribution_Type', MD_Distribution_Type)


# Complex type {http://www.isotc211.org/2005/gmd}MD_Format_Type with content type ELEMENT_ONLY
class MD_Format_Type (AbstractObject_Type):
    """Description of the form of the data to be distributed"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_Format_Type')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/distribution.xsd', 145, 1)
    _ElementMap = AbstractObject_Type._ElementMap.copy()
    _AttributeMap = AbstractObject_Type._AttributeMap.copy()
    # Base type is AbstractObject_Type
    
    # Element {http://www.isotc211.org/2005/gmd}name uses Python identifier name
    __name = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'name'), 'name', '__httpwww_isotc211_org2005gmd_MD_Format_Type_httpwww_isotc211_org2005gmdname', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/distribution.xsd', 152, 5), )

    
    name = property(__name.value, __name.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}version uses Python identifier version
    __version = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'version'), 'version', '__httpwww_isotc211_org2005gmd_MD_Format_Type_httpwww_isotc211_org2005gmdversion', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/distribution.xsd', 153, 5), )

    
    version = property(__version.value, __version.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}amendmentNumber uses Python identifier amendmentNumber
    __amendmentNumber = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'amendmentNumber'), 'amendmentNumber', '__httpwww_isotc211_org2005gmd_MD_Format_Type_httpwww_isotc211_org2005gmdamendmentNumber', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/distribution.xsd', 154, 5), )

    
    amendmentNumber = property(__amendmentNumber.value, __amendmentNumber.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}specification uses Python identifier specification
    __specification = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'specification'), 'specification', '__httpwww_isotc211_org2005gmd_MD_Format_Type_httpwww_isotc211_org2005gmdspecification', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/distribution.xsd', 155, 5), )

    
    specification = property(__specification.value, __specification.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}fileDecompressionTechnique uses Python identifier fileDecompressionTechnique
    __fileDecompressionTechnique = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'fileDecompressionTechnique'), 'fileDecompressionTechnique', '__httpwww_isotc211_org2005gmd_MD_Format_Type_httpwww_isotc211_org2005gmdfileDecompressionTechnique', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/distribution.xsd', 156, 5), )

    
    fileDecompressionTechnique = property(__fileDecompressionTechnique.value, __fileDecompressionTechnique.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}formatDistributor uses Python identifier formatDistributor
    __formatDistributor = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'formatDistributor'), 'formatDistributor', '__httpwww_isotc211_org2005gmd_MD_Format_Type_httpwww_isotc211_org2005gmdformatDistributor', True, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/distribution.xsd', 157, 5), )

    
    formatDistributor = property(__formatDistributor.value, __formatDistributor.set, None, None)

    
    # Attribute id inherited from {http://www.isotc211.org/2005/gco}AbstractObject_Type
    
    # Attribute uuid inherited from {http://www.isotc211.org/2005/gco}AbstractObject_Type
    _ElementMap.update({
        __name.name() : __name,
        __version.name() : __version,
        __amendmentNumber.name() : __amendmentNumber,
        __specification.name() : __specification,
        __fileDecompressionTechnique.name() : __fileDecompressionTechnique,
        __formatDistributor.name() : __formatDistributor
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.MD_Format_Type = MD_Format_Type
_Namespace_gmd.addCategoryObject('typeBinding', 'MD_Format_Type', MD_Format_Type)


# Complex type {http://www.isotc211.org/2005/gmd}EX_TemporalExtent_Type with content type ELEMENT_ONLY
class EX_TemporalExtent_Type (AbstractObject_Type):
    """Time period covered by the content of the dataset"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'EX_TemporalExtent_Type')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/extent.xsd', 17, 1)
    _ElementMap = AbstractObject_Type._ElementMap.copy()
    _AttributeMap = AbstractObject_Type._AttributeMap.copy()
    # Base type is AbstractObject_Type
    
    # Element {http://www.isotc211.org/2005/gmd}extent uses Python identifier extent
    __extent = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'extent'), 'extent', '__httpwww_isotc211_org2005gmd_EX_TemporalExtent_Type_httpwww_isotc211_org2005gmdextent', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/extent.xsd', 24, 5), )

    
    extent = property(__extent.value, __extent.set, None, None)

    
    # Attribute id inherited from {http://www.isotc211.org/2005/gco}AbstractObject_Type
    
    # Attribute uuid inherited from {http://www.isotc211.org/2005/gco}AbstractObject_Type
    _ElementMap.update({
        __extent.name() : __extent
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.EX_TemporalExtent_Type = EX_TemporalExtent_Type
_Namespace_gmd.addCategoryObject('typeBinding', 'EX_TemporalExtent_Type', EX_TemporalExtent_Type)


# Complex type {http://www.isotc211.org/2005/gmd}EX_VerticalExtent_Type with content type ELEMENT_ONLY
class EX_VerticalExtent_Type (AbstractObject_Type):
    """Vertical domain of dataset"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'EX_VerticalExtent_Type')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/extent.xsd', 40, 1)
    _ElementMap = AbstractObject_Type._ElementMap.copy()
    _AttributeMap = AbstractObject_Type._AttributeMap.copy()
    # Base type is AbstractObject_Type
    
    # Element {http://www.isotc211.org/2005/gmd}minimumValue uses Python identifier minimumValue
    __minimumValue = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'minimumValue'), 'minimumValue', '__httpwww_isotc211_org2005gmd_EX_VerticalExtent_Type_httpwww_isotc211_org2005gmdminimumValue', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/extent.xsd', 47, 5), )

    
    minimumValue = property(__minimumValue.value, __minimumValue.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}maximumValue uses Python identifier maximumValue
    __maximumValue = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'maximumValue'), 'maximumValue', '__httpwww_isotc211_org2005gmd_EX_VerticalExtent_Type_httpwww_isotc211_org2005gmdmaximumValue', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/extent.xsd', 48, 5), )

    
    maximumValue = property(__maximumValue.value, __maximumValue.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}verticalCRS uses Python identifier verticalCRS
    __verticalCRS = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'verticalCRS'), 'verticalCRS', '__httpwww_isotc211_org2005gmd_EX_VerticalExtent_Type_httpwww_isotc211_org2005gmdverticalCRS', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/extent.xsd', 49, 5), )

    
    verticalCRS = property(__verticalCRS.value, __verticalCRS.set, None, None)

    
    # Attribute id inherited from {http://www.isotc211.org/2005/gco}AbstractObject_Type
    
    # Attribute uuid inherited from {http://www.isotc211.org/2005/gco}AbstractObject_Type
    _ElementMap.update({
        __minimumValue.name() : __minimumValue,
        __maximumValue.name() : __maximumValue,
        __verticalCRS.name() : __verticalCRS
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.EX_VerticalExtent_Type = EX_VerticalExtent_Type
_Namespace_gmd.addCategoryObject('typeBinding', 'EX_VerticalExtent_Type', EX_VerticalExtent_Type)


# Complex type {http://www.isotc211.org/2005/gmd}EX_Extent_Type with content type ELEMENT_ONLY
class EX_Extent_Type (AbstractObject_Type):
    """Information about spatial, vertical, and temporal extent"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'EX_Extent_Type')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/extent.xsd', 88, 1)
    _ElementMap = AbstractObject_Type._ElementMap.copy()
    _AttributeMap = AbstractObject_Type._AttributeMap.copy()
    # Base type is AbstractObject_Type
    
    # Element {http://www.isotc211.org/2005/gmd}description uses Python identifier description
    __description = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'description'), 'description', '__httpwww_isotc211_org2005gmd_EX_Extent_Type_httpwww_isotc211_org2005gmddescription', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/extent.xsd', 95, 5), )

    
    description = property(__description.value, __description.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}geographicElement uses Python identifier geographicElement
    __geographicElement = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'geographicElement'), 'geographicElement', '__httpwww_isotc211_org2005gmd_EX_Extent_Type_httpwww_isotc211_org2005gmdgeographicElement', True, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/extent.xsd', 96, 5), )

    
    geographicElement = property(__geographicElement.value, __geographicElement.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}temporalElement uses Python identifier temporalElement
    __temporalElement = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'temporalElement'), 'temporalElement', '__httpwww_isotc211_org2005gmd_EX_Extent_Type_httpwww_isotc211_org2005gmdtemporalElement', True, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/extent.xsd', 97, 5), )

    
    temporalElement = property(__temporalElement.value, __temporalElement.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}verticalElement uses Python identifier verticalElement
    __verticalElement = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'verticalElement'), 'verticalElement', '__httpwww_isotc211_org2005gmd_EX_Extent_Type_httpwww_isotc211_org2005gmdverticalElement', True, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/extent.xsd', 98, 5), )

    
    verticalElement = property(__verticalElement.value, __verticalElement.set, None, None)

    
    # Attribute id inherited from {http://www.isotc211.org/2005/gco}AbstractObject_Type
    
    # Attribute uuid inherited from {http://www.isotc211.org/2005/gco}AbstractObject_Type
    _ElementMap.update({
        __description.name() : __description,
        __geographicElement.name() : __geographicElement,
        __temporalElement.name() : __temporalElement,
        __verticalElement.name() : __verticalElement
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.EX_Extent_Type = EX_Extent_Type
_Namespace_gmd.addCategoryObject('typeBinding', 'EX_Extent_Type', EX_Extent_Type)


# Complex type {http://www.isotc211.org/2005/gmd}AbstractEX_GeographicExtent_Type with content type ELEMENT_ONLY
class AbstractEX_GeographicExtent_Type (AbstractObject_Type):
    """Geographic area of the dataset"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = True
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'AbstractEX_GeographicExtent_Type')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/extent.xsd', 114, 1)
    _ElementMap = AbstractObject_Type._ElementMap.copy()
    _AttributeMap = AbstractObject_Type._AttributeMap.copy()
    # Base type is AbstractObject_Type
    
    # Element {http://www.isotc211.org/2005/gmd}extentTypeCode uses Python identifier extentTypeCode
    __extentTypeCode = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'extentTypeCode'), 'extentTypeCode', '__httpwww_isotc211_org2005gmd_AbstractEX_GeographicExtent_Type_httpwww_isotc211_org2005gmdextentTypeCode', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/extent.xsd', 121, 5), )

    
    extentTypeCode = property(__extentTypeCode.value, __extentTypeCode.set, None, None)

    
    # Attribute id inherited from {http://www.isotc211.org/2005/gco}AbstractObject_Type
    
    # Attribute uuid inherited from {http://www.isotc211.org/2005/gco}AbstractObject_Type
    _ElementMap.update({
        __extentTypeCode.name() : __extentTypeCode
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.AbstractEX_GeographicExtent_Type = AbstractEX_GeographicExtent_Type
_Namespace_gmd.addCategoryObject('typeBinding', 'AbstractEX_GeographicExtent_Type', AbstractEX_GeographicExtent_Type)


# Complex type {http://www.isotc211.org/2005/gmd}PT_FreeText_Type with content type ELEMENT_ONLY
class PT_FreeText_Type (AbstractObject_Type):
    """Complex type {http://www.isotc211.org/2005/gmd}PT_FreeText_Type with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'PT_FreeText_Type')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/freeText.xsd', 14, 1)
    _ElementMap = AbstractObject_Type._ElementMap.copy()
    _AttributeMap = AbstractObject_Type._AttributeMap.copy()
    # Base type is AbstractObject_Type
    
    # Element {http://www.isotc211.org/2005/gmd}textGroup uses Python identifier textGroup
    __textGroup = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'textGroup'), 'textGroup', '__httpwww_isotc211_org2005gmd_PT_FreeText_Type_httpwww_isotc211_org2005gmdtextGroup', True, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/freeText.xsd', 18, 5), )

    
    textGroup = property(__textGroup.value, __textGroup.set, None, None)

    
    # Attribute id inherited from {http://www.isotc211.org/2005/gco}AbstractObject_Type
    
    # Attribute uuid inherited from {http://www.isotc211.org/2005/gco}AbstractObject_Type
    _ElementMap.update({
        __textGroup.name() : __textGroup
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.PT_FreeText_Type = PT_FreeText_Type
_Namespace_gmd.addCategoryObject('typeBinding', 'PT_FreeText_Type', PT_FreeText_Type)


# Complex type {http://www.isotc211.org/2005/gmd}PT_Locale_Type with content type ELEMENT_ONLY
class PT_Locale_Type (AbstractObject_Type):
    """Complex type {http://www.isotc211.org/2005/gmd}PT_Locale_Type with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'PT_Locale_Type')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/freeText.xsd', 36, 1)
    _ElementMap = AbstractObject_Type._ElementMap.copy()
    _AttributeMap = AbstractObject_Type._AttributeMap.copy()
    # Base type is AbstractObject_Type
    
    # Element {http://www.isotc211.org/2005/gmd}languageCode uses Python identifier languageCode
    __languageCode = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'languageCode'), 'languageCode', '__httpwww_isotc211_org2005gmd_PT_Locale_Type_httpwww_isotc211_org2005gmdlanguageCode', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/freeText.xsd', 40, 5), )

    
    languageCode = property(__languageCode.value, __languageCode.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}country uses Python identifier country
    __country = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'country'), 'country', '__httpwww_isotc211_org2005gmd_PT_Locale_Type_httpwww_isotc211_org2005gmdcountry', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/freeText.xsd', 41, 5), )

    
    country = property(__country.value, __country.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}characterEncoding uses Python identifier characterEncoding
    __characterEncoding = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'characterEncoding'), 'characterEncoding', '__httpwww_isotc211_org2005gmd_PT_Locale_Type_httpwww_isotc211_org2005gmdcharacterEncoding', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/freeText.xsd', 42, 5), )

    
    characterEncoding = property(__characterEncoding.value, __characterEncoding.set, None, None)

    
    # Attribute id inherited from {http://www.isotc211.org/2005/gco}AbstractObject_Type
    
    # Attribute uuid inherited from {http://www.isotc211.org/2005/gco}AbstractObject_Type
    _ElementMap.update({
        __languageCode.name() : __languageCode,
        __country.name() : __country,
        __characterEncoding.name() : __characterEncoding
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.PT_Locale_Type = PT_Locale_Type
_Namespace_gmd.addCategoryObject('typeBinding', 'PT_Locale_Type', PT_Locale_Type)


# Complex type {http://www.isotc211.org/2005/gmd}AbstractMD_Identification_Type with content type ELEMENT_ONLY
class AbstractMD_Identification_Type (AbstractObject_Type):
    """Basic information about data"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = True
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'AbstractMD_Identification_Type')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 16, 1)
    _ElementMap = AbstractObject_Type._ElementMap.copy()
    _AttributeMap = AbstractObject_Type._AttributeMap.copy()
    # Base type is AbstractObject_Type
    
    # Element {http://www.isotc211.org/2005/gmd}citation uses Python identifier citation
    __citation = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'citation'), 'citation', '__httpwww_isotc211_org2005gmd_AbstractMD_Identification_Type_httpwww_isotc211_org2005gmdcitation', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 23, 5), )

    
    citation = property(__citation.value, __citation.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}abstract uses Python identifier abstract
    __abstract = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'abstract'), 'abstract', '__httpwww_isotc211_org2005gmd_AbstractMD_Identification_Type_httpwww_isotc211_org2005gmdabstract', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 24, 5), )

    
    abstract = property(__abstract.value, __abstract.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}purpose uses Python identifier purpose
    __purpose = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'purpose'), 'purpose', '__httpwww_isotc211_org2005gmd_AbstractMD_Identification_Type_httpwww_isotc211_org2005gmdpurpose', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 25, 5), )

    
    purpose = property(__purpose.value, __purpose.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}credit uses Python identifier credit
    __credit = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'credit'), 'credit', '__httpwww_isotc211_org2005gmd_AbstractMD_Identification_Type_httpwww_isotc211_org2005gmdcredit', True, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 26, 5), )

    
    credit = property(__credit.value, __credit.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}status uses Python identifier status
    __status = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'status'), 'status', '__httpwww_isotc211_org2005gmd_AbstractMD_Identification_Type_httpwww_isotc211_org2005gmdstatus', True, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 27, 5), )

    
    status = property(__status.value, __status.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}pointOfContact uses Python identifier pointOfContact
    __pointOfContact = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'pointOfContact'), 'pointOfContact', '__httpwww_isotc211_org2005gmd_AbstractMD_Identification_Type_httpwww_isotc211_org2005gmdpointOfContact', True, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 28, 5), )

    
    pointOfContact = property(__pointOfContact.value, __pointOfContact.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}resourceMaintenance uses Python identifier resourceMaintenance
    __resourceMaintenance = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'resourceMaintenance'), 'resourceMaintenance', '__httpwww_isotc211_org2005gmd_AbstractMD_Identification_Type_httpwww_isotc211_org2005gmdresourceMaintenance', True, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 29, 5), )

    
    resourceMaintenance = property(__resourceMaintenance.value, __resourceMaintenance.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}graphicOverview uses Python identifier graphicOverview
    __graphicOverview = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'graphicOverview'), 'graphicOverview', '__httpwww_isotc211_org2005gmd_AbstractMD_Identification_Type_httpwww_isotc211_org2005gmdgraphicOverview', True, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 30, 5), )

    
    graphicOverview = property(__graphicOverview.value, __graphicOverview.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}resourceFormat uses Python identifier resourceFormat
    __resourceFormat = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'resourceFormat'), 'resourceFormat', '__httpwww_isotc211_org2005gmd_AbstractMD_Identification_Type_httpwww_isotc211_org2005gmdresourceFormat', True, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 31, 5), )

    
    resourceFormat = property(__resourceFormat.value, __resourceFormat.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}descriptiveKeywords uses Python identifier descriptiveKeywords
    __descriptiveKeywords = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'descriptiveKeywords'), 'descriptiveKeywords', '__httpwww_isotc211_org2005gmd_AbstractMD_Identification_Type_httpwww_isotc211_org2005gmddescriptiveKeywords', True, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 32, 5), )

    
    descriptiveKeywords = property(__descriptiveKeywords.value, __descriptiveKeywords.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}resourceSpecificUsage uses Python identifier resourceSpecificUsage
    __resourceSpecificUsage = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'resourceSpecificUsage'), 'resourceSpecificUsage', '__httpwww_isotc211_org2005gmd_AbstractMD_Identification_Type_httpwww_isotc211_org2005gmdresourceSpecificUsage', True, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 33, 5), )

    
    resourceSpecificUsage = property(__resourceSpecificUsage.value, __resourceSpecificUsage.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}resourceConstraints uses Python identifier resourceConstraints
    __resourceConstraints = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'resourceConstraints'), 'resourceConstraints', '__httpwww_isotc211_org2005gmd_AbstractMD_Identification_Type_httpwww_isotc211_org2005gmdresourceConstraints', True, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 34, 5), )

    
    resourceConstraints = property(__resourceConstraints.value, __resourceConstraints.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}aggregationInfo uses Python identifier aggregationInfo
    __aggregationInfo = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'aggregationInfo'), 'aggregationInfo', '__httpwww_isotc211_org2005gmd_AbstractMD_Identification_Type_httpwww_isotc211_org2005gmdaggregationInfo', True, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 35, 5), )

    
    aggregationInfo = property(__aggregationInfo.value, __aggregationInfo.set, None, None)

    
    # Attribute id inherited from {http://www.isotc211.org/2005/gco}AbstractObject_Type
    
    # Attribute uuid inherited from {http://www.isotc211.org/2005/gco}AbstractObject_Type
    _ElementMap.update({
        __citation.name() : __citation,
        __abstract.name() : __abstract,
        __purpose.name() : __purpose,
        __credit.name() : __credit,
        __status.name() : __status,
        __pointOfContact.name() : __pointOfContact,
        __resourceMaintenance.name() : __resourceMaintenance,
        __graphicOverview.name() : __graphicOverview,
        __resourceFormat.name() : __resourceFormat,
        __descriptiveKeywords.name() : __descriptiveKeywords,
        __resourceSpecificUsage.name() : __resourceSpecificUsage,
        __resourceConstraints.name() : __resourceConstraints,
        __aggregationInfo.name() : __aggregationInfo
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.AbstractMD_Identification_Type = AbstractMD_Identification_Type
_Namespace_gmd.addCategoryObject('typeBinding', 'AbstractMD_Identification_Type', AbstractMD_Identification_Type)


# Complex type {http://www.isotc211.org/2005/gmd}MD_BrowseGraphic_Type with content type ELEMENT_ONLY
class MD_BrowseGraphic_Type (AbstractObject_Type):
    """Graphic that provides an illustration of the dataset (should include a legend for the graphic)"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_BrowseGraphic_Type')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 51, 1)
    _ElementMap = AbstractObject_Type._ElementMap.copy()
    _AttributeMap = AbstractObject_Type._AttributeMap.copy()
    # Base type is AbstractObject_Type
    
    # Element {http://www.isotc211.org/2005/gmd}fileName uses Python identifier fileName
    __fileName = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'fileName'), 'fileName', '__httpwww_isotc211_org2005gmd_MD_BrowseGraphic_Type_httpwww_isotc211_org2005gmdfileName', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 58, 5), )

    
    fileName = property(__fileName.value, __fileName.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}fileDescription uses Python identifier fileDescription
    __fileDescription = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'fileDescription'), 'fileDescription', '__httpwww_isotc211_org2005gmd_MD_BrowseGraphic_Type_httpwww_isotc211_org2005gmdfileDescription', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 59, 5), )

    
    fileDescription = property(__fileDescription.value, __fileDescription.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}fileType uses Python identifier fileType
    __fileType = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'fileType'), 'fileType', '__httpwww_isotc211_org2005gmd_MD_BrowseGraphic_Type_httpwww_isotc211_org2005gmdfileType', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 60, 5), )

    
    fileType = property(__fileType.value, __fileType.set, None, None)

    
    # Attribute id inherited from {http://www.isotc211.org/2005/gco}AbstractObject_Type
    
    # Attribute uuid inherited from {http://www.isotc211.org/2005/gco}AbstractObject_Type
    _ElementMap.update({
        __fileName.name() : __fileName,
        __fileDescription.name() : __fileDescription,
        __fileType.name() : __fileType
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.MD_BrowseGraphic_Type = MD_BrowseGraphic_Type
_Namespace_gmd.addCategoryObject('typeBinding', 'MD_BrowseGraphic_Type', MD_BrowseGraphic_Type)


# Complex type {http://www.isotc211.org/2005/gmd}MD_RepresentativeFraction_Type with content type ELEMENT_ONLY
class MD_RepresentativeFraction_Type (AbstractObject_Type):
    """Complex type {http://www.isotc211.org/2005/gmd}MD_RepresentativeFraction_Type with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_RepresentativeFraction_Type')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 122, 1)
    _ElementMap = AbstractObject_Type._ElementMap.copy()
    _AttributeMap = AbstractObject_Type._AttributeMap.copy()
    # Base type is AbstractObject_Type
    
    # Element {http://www.isotc211.org/2005/gmd}denominator uses Python identifier denominator
    __denominator = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'denominator'), 'denominator', '__httpwww_isotc211_org2005gmd_MD_RepresentativeFraction_Type_httpwww_isotc211_org2005gmddenominator', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 126, 5), )

    
    denominator = property(__denominator.value, __denominator.set, None, None)

    
    # Attribute id inherited from {http://www.isotc211.org/2005/gco}AbstractObject_Type
    
    # Attribute uuid inherited from {http://www.isotc211.org/2005/gco}AbstractObject_Type
    _ElementMap.update({
        __denominator.name() : __denominator
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.MD_RepresentativeFraction_Type = MD_RepresentativeFraction_Type
_Namespace_gmd.addCategoryObject('typeBinding', 'MD_RepresentativeFraction_Type', MD_RepresentativeFraction_Type)


# Complex type {http://www.isotc211.org/2005/gmd}MD_Usage_Type with content type ELEMENT_ONLY
class MD_Usage_Type (AbstractObject_Type):
    """Brief description of ways in which the dataset is currently used."""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_Usage_Type')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 142, 1)
    _ElementMap = AbstractObject_Type._ElementMap.copy()
    _AttributeMap = AbstractObject_Type._AttributeMap.copy()
    # Base type is AbstractObject_Type
    
    # Element {http://www.isotc211.org/2005/gmd}specificUsage uses Python identifier specificUsage
    __specificUsage = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'specificUsage'), 'specificUsage', '__httpwww_isotc211_org2005gmd_MD_Usage_Type_httpwww_isotc211_org2005gmdspecificUsage', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 149, 5), )

    
    specificUsage = property(__specificUsage.value, __specificUsage.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}usageDateTime uses Python identifier usageDateTime
    __usageDateTime = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'usageDateTime'), 'usageDateTime', '__httpwww_isotc211_org2005gmd_MD_Usage_Type_httpwww_isotc211_org2005gmdusageDateTime', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 150, 5), )

    
    usageDateTime = property(__usageDateTime.value, __usageDateTime.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}userDeterminedLimitations uses Python identifier userDeterminedLimitations
    __userDeterminedLimitations = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'userDeterminedLimitations'), 'userDeterminedLimitations', '__httpwww_isotc211_org2005gmd_MD_Usage_Type_httpwww_isotc211_org2005gmduserDeterminedLimitations', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 151, 5), )

    
    userDeterminedLimitations = property(__userDeterminedLimitations.value, __userDeterminedLimitations.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}userContactInfo uses Python identifier userContactInfo
    __userContactInfo = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'userContactInfo'), 'userContactInfo', '__httpwww_isotc211_org2005gmd_MD_Usage_Type_httpwww_isotc211_org2005gmduserContactInfo', True, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 152, 5), )

    
    userContactInfo = property(__userContactInfo.value, __userContactInfo.set, None, None)

    
    # Attribute id inherited from {http://www.isotc211.org/2005/gco}AbstractObject_Type
    
    # Attribute uuid inherited from {http://www.isotc211.org/2005/gco}AbstractObject_Type
    _ElementMap.update({
        __specificUsage.name() : __specificUsage,
        __usageDateTime.name() : __usageDateTime,
        __userDeterminedLimitations.name() : __userDeterminedLimitations,
        __userContactInfo.name() : __userContactInfo
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.MD_Usage_Type = MD_Usage_Type
_Namespace_gmd.addCategoryObject('typeBinding', 'MD_Usage_Type', MD_Usage_Type)


# Complex type {http://www.isotc211.org/2005/gmd}MD_Keywords_Type with content type ELEMENT_ONLY
class MD_Keywords_Type (AbstractObject_Type):
    """Keywords, their type and reference source"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_Keywords_Type')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 168, 1)
    _ElementMap = AbstractObject_Type._ElementMap.copy()
    _AttributeMap = AbstractObject_Type._AttributeMap.copy()
    # Base type is AbstractObject_Type
    
    # Element {http://www.isotc211.org/2005/gmd}keyword uses Python identifier keyword
    __keyword = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'keyword'), 'keyword', '__httpwww_isotc211_org2005gmd_MD_Keywords_Type_httpwww_isotc211_org2005gmdkeyword', True, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 175, 5), )

    
    keyword = property(__keyword.value, __keyword.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}type uses Python identifier type
    __type = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'type'), 'type', '__httpwww_isotc211_org2005gmd_MD_Keywords_Type_httpwww_isotc211_org2005gmdtype', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 176, 5), )

    
    type = property(__type.value, __type.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}thesaurusName uses Python identifier thesaurusName
    __thesaurusName = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'thesaurusName'), 'thesaurusName', '__httpwww_isotc211_org2005gmd_MD_Keywords_Type_httpwww_isotc211_org2005gmdthesaurusName', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 177, 5), )

    
    thesaurusName = property(__thesaurusName.value, __thesaurusName.set, None, None)

    
    # Attribute id inherited from {http://www.isotc211.org/2005/gco}AbstractObject_Type
    
    # Attribute uuid inherited from {http://www.isotc211.org/2005/gco}AbstractObject_Type
    _ElementMap.update({
        __keyword.name() : __keyword,
        __type.name() : __type,
        __thesaurusName.name() : __thesaurusName
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.MD_Keywords_Type = MD_Keywords_Type
_Namespace_gmd.addCategoryObject('typeBinding', 'MD_Keywords_Type', MD_Keywords_Type)


# Complex type {http://www.isotc211.org/2005/gmd}DS_Association_Type with content type EMPTY
class DS_Association_Type (AbstractObject_Type):
    """Complex type {http://www.isotc211.org/2005/gmd}DS_Association_Type with content type EMPTY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_EMPTY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'DS_Association_Type')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 193, 1)
    _ElementMap = AbstractObject_Type._ElementMap.copy()
    _AttributeMap = AbstractObject_Type._AttributeMap.copy()
    # Base type is AbstractObject_Type
    
    # Attribute id inherited from {http://www.isotc211.org/2005/gco}AbstractObject_Type
    
    # Attribute uuid inherited from {http://www.isotc211.org/2005/gco}AbstractObject_Type
    _ElementMap.update({
        
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.DS_Association_Type = DS_Association_Type
_Namespace_gmd.addCategoryObject('typeBinding', 'DS_Association_Type', DS_Association_Type)


# Complex type {http://www.isotc211.org/2005/gmd}MD_AggregateInformation_Type with content type ELEMENT_ONLY
class MD_AggregateInformation_Type (AbstractObject_Type):
    """Encapsulates the dataset aggregation information"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_AggregateInformation_Type')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 211, 1)
    _ElementMap = AbstractObject_Type._ElementMap.copy()
    _AttributeMap = AbstractObject_Type._AttributeMap.copy()
    # Base type is AbstractObject_Type
    
    # Element {http://www.isotc211.org/2005/gmd}aggregateDataSetName uses Python identifier aggregateDataSetName
    __aggregateDataSetName = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'aggregateDataSetName'), 'aggregateDataSetName', '__httpwww_isotc211_org2005gmd_MD_AggregateInformation_Type_httpwww_isotc211_org2005gmdaggregateDataSetName', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 218, 5), )

    
    aggregateDataSetName = property(__aggregateDataSetName.value, __aggregateDataSetName.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}aggregateDataSetIdentifier uses Python identifier aggregateDataSetIdentifier
    __aggregateDataSetIdentifier = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'aggregateDataSetIdentifier'), 'aggregateDataSetIdentifier', '__httpwww_isotc211_org2005gmd_MD_AggregateInformation_Type_httpwww_isotc211_org2005gmdaggregateDataSetIdentifier', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 219, 5), )

    
    aggregateDataSetIdentifier = property(__aggregateDataSetIdentifier.value, __aggregateDataSetIdentifier.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}associationType uses Python identifier associationType
    __associationType = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'associationType'), 'associationType', '__httpwww_isotc211_org2005gmd_MD_AggregateInformation_Type_httpwww_isotc211_org2005gmdassociationType', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 220, 5), )

    
    associationType = property(__associationType.value, __associationType.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}initiativeType uses Python identifier initiativeType
    __initiativeType = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'initiativeType'), 'initiativeType', '__httpwww_isotc211_org2005gmd_MD_AggregateInformation_Type_httpwww_isotc211_org2005gmdinitiativeType', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 221, 5), )

    
    initiativeType = property(__initiativeType.value, __initiativeType.set, None, None)

    
    # Attribute id inherited from {http://www.isotc211.org/2005/gco}AbstractObject_Type
    
    # Attribute uuid inherited from {http://www.isotc211.org/2005/gco}AbstractObject_Type
    _ElementMap.update({
        __aggregateDataSetName.name() : __aggregateDataSetName,
        __aggregateDataSetIdentifier.name() : __aggregateDataSetIdentifier,
        __associationType.name() : __associationType,
        __initiativeType.name() : __initiativeType
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.MD_AggregateInformation_Type = MD_AggregateInformation_Type
_Namespace_gmd.addCategoryObject('typeBinding', 'MD_AggregateInformation_Type', MD_AggregateInformation_Type)


# Complex type {http://www.isotc211.org/2005/gmd}MD_MaintenanceInformation_Type with content type ELEMENT_ONLY
class MD_MaintenanceInformation_Type (AbstractObject_Type):
    """Information about the scope and frequency of updating"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_MaintenanceInformation_Type')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/maintenance.xsd', 15, 1)
    _ElementMap = AbstractObject_Type._ElementMap.copy()
    _AttributeMap = AbstractObject_Type._AttributeMap.copy()
    # Base type is AbstractObject_Type
    
    # Element {http://www.isotc211.org/2005/gmd}maintenanceAndUpdateFrequency uses Python identifier maintenanceAndUpdateFrequency
    __maintenanceAndUpdateFrequency = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'maintenanceAndUpdateFrequency'), 'maintenanceAndUpdateFrequency', '__httpwww_isotc211_org2005gmd_MD_MaintenanceInformation_Type_httpwww_isotc211_org2005gmdmaintenanceAndUpdateFrequency', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/maintenance.xsd', 22, 5), )

    
    maintenanceAndUpdateFrequency = property(__maintenanceAndUpdateFrequency.value, __maintenanceAndUpdateFrequency.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}dateOfNextUpdate uses Python identifier dateOfNextUpdate
    __dateOfNextUpdate = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'dateOfNextUpdate'), 'dateOfNextUpdate', '__httpwww_isotc211_org2005gmd_MD_MaintenanceInformation_Type_httpwww_isotc211_org2005gmddateOfNextUpdate', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/maintenance.xsd', 23, 5), )

    
    dateOfNextUpdate = property(__dateOfNextUpdate.value, __dateOfNextUpdate.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}userDefinedMaintenanceFrequency uses Python identifier userDefinedMaintenanceFrequency
    __userDefinedMaintenanceFrequency = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'userDefinedMaintenanceFrequency'), 'userDefinedMaintenanceFrequency', '__httpwww_isotc211_org2005gmd_MD_MaintenanceInformation_Type_httpwww_isotc211_org2005gmduserDefinedMaintenanceFrequency', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/maintenance.xsd', 24, 5), )

    
    userDefinedMaintenanceFrequency = property(__userDefinedMaintenanceFrequency.value, __userDefinedMaintenanceFrequency.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}updateScope uses Python identifier updateScope
    __updateScope = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'updateScope'), 'updateScope', '__httpwww_isotc211_org2005gmd_MD_MaintenanceInformation_Type_httpwww_isotc211_org2005gmdupdateScope', True, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/maintenance.xsd', 25, 5), )

    
    updateScope = property(__updateScope.value, __updateScope.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}updateScopeDescription uses Python identifier updateScopeDescription
    __updateScopeDescription = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'updateScopeDescription'), 'updateScopeDescription', '__httpwww_isotc211_org2005gmd_MD_MaintenanceInformation_Type_httpwww_isotc211_org2005gmdupdateScopeDescription', True, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/maintenance.xsd', 26, 5), )

    
    updateScopeDescription = property(__updateScopeDescription.value, __updateScopeDescription.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}maintenanceNote uses Python identifier maintenanceNote
    __maintenanceNote = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'maintenanceNote'), 'maintenanceNote', '__httpwww_isotc211_org2005gmd_MD_MaintenanceInformation_Type_httpwww_isotc211_org2005gmdmaintenanceNote', True, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/maintenance.xsd', 27, 5), )

    
    maintenanceNote = property(__maintenanceNote.value, __maintenanceNote.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}contact uses Python identifier contact
    __contact = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'contact'), 'contact', '__httpwww_isotc211_org2005gmd_MD_MaintenanceInformation_Type_httpwww_isotc211_org2005gmdcontact', True, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/maintenance.xsd', 28, 5), )

    
    contact = property(__contact.value, __contact.set, None, None)

    
    # Attribute id inherited from {http://www.isotc211.org/2005/gco}AbstractObject_Type
    
    # Attribute uuid inherited from {http://www.isotc211.org/2005/gco}AbstractObject_Type
    _ElementMap.update({
        __maintenanceAndUpdateFrequency.name() : __maintenanceAndUpdateFrequency,
        __dateOfNextUpdate.name() : __dateOfNextUpdate,
        __userDefinedMaintenanceFrequency.name() : __userDefinedMaintenanceFrequency,
        __updateScope.name() : __updateScope,
        __updateScopeDescription.name() : __updateScopeDescription,
        __maintenanceNote.name() : __maintenanceNote,
        __contact.name() : __contact
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.MD_MaintenanceInformation_Type = MD_MaintenanceInformation_Type
_Namespace_gmd.addCategoryObject('typeBinding', 'MD_MaintenanceInformation_Type', MD_MaintenanceInformation_Type)


# Complex type {http://www.isotc211.org/2005/gmd}AbstractDS_Aggregate_Type with content type ELEMENT_ONLY
class AbstractDS_Aggregate_Type (AbstractObject_Type):
    """Identifiable collection of datasets"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = True
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'AbstractDS_Aggregate_Type')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataApplication.xsd', 14, 1)
    _ElementMap = AbstractObject_Type._ElementMap.copy()
    _AttributeMap = AbstractObject_Type._AttributeMap.copy()
    # Base type is AbstractObject_Type
    
    # Element {http://www.isotc211.org/2005/gmd}composedOf uses Python identifier composedOf
    __composedOf = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'composedOf'), 'composedOf', '__httpwww_isotc211_org2005gmd_AbstractDS_Aggregate_Type_httpwww_isotc211_org2005gmdcomposedOf', True, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataApplication.xsd', 21, 5), )

    
    composedOf = property(__composedOf.value, __composedOf.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}seriesMetadata uses Python identifier seriesMetadata
    __seriesMetadata = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'seriesMetadata'), 'seriesMetadata', '__httpwww_isotc211_org2005gmd_AbstractDS_Aggregate_Type_httpwww_isotc211_org2005gmdseriesMetadata', True, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataApplication.xsd', 22, 5), )

    
    seriesMetadata = property(__seriesMetadata.value, __seriesMetadata.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}subset uses Python identifier subset
    __subset = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'subset'), 'subset', '__httpwww_isotc211_org2005gmd_AbstractDS_Aggregate_Type_httpwww_isotc211_org2005gmdsubset', True, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataApplication.xsd', 23, 5), )

    
    subset = property(__subset.value, __subset.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}superset uses Python identifier superset
    __superset = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'superset'), 'superset', '__httpwww_isotc211_org2005gmd_AbstractDS_Aggregate_Type_httpwww_isotc211_org2005gmdsuperset', True, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataApplication.xsd', 24, 5), )

    
    superset = property(__superset.value, __superset.set, None, None)

    
    # Attribute id inherited from {http://www.isotc211.org/2005/gco}AbstractObject_Type
    
    # Attribute uuid inherited from {http://www.isotc211.org/2005/gco}AbstractObject_Type
    _ElementMap.update({
        __composedOf.name() : __composedOf,
        __seriesMetadata.name() : __seriesMetadata,
        __subset.name() : __subset,
        __superset.name() : __superset
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.AbstractDS_Aggregate_Type = AbstractDS_Aggregate_Type
_Namespace_gmd.addCategoryObject('typeBinding', 'AbstractDS_Aggregate_Type', AbstractDS_Aggregate_Type)


# Complex type {http://www.isotc211.org/2005/gmd}DS_DataSet_Type with content type ELEMENT_ONLY
class DS_DataSet_Type (AbstractObject_Type):
    """Identifiable collection of data"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'DS_DataSet_Type')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataApplication.xsd', 40, 1)
    _ElementMap = AbstractObject_Type._ElementMap.copy()
    _AttributeMap = AbstractObject_Type._AttributeMap.copy()
    # Base type is AbstractObject_Type
    
    # Element {http://www.isotc211.org/2005/gmd}has uses Python identifier has
    __has = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'has'), 'has', '__httpwww_isotc211_org2005gmd_DS_DataSet_Type_httpwww_isotc211_org2005gmdhas', True, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataApplication.xsd', 47, 5), )

    
    has = property(__has.value, __has.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}partOf uses Python identifier partOf
    __partOf = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'partOf'), 'partOf', '__httpwww_isotc211_org2005gmd_DS_DataSet_Type_httpwww_isotc211_org2005gmdpartOf', True, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataApplication.xsd', 48, 5), )

    
    partOf = property(__partOf.value, __partOf.set, None, None)

    
    # Attribute id inherited from {http://www.isotc211.org/2005/gco}AbstractObject_Type
    
    # Attribute uuid inherited from {http://www.isotc211.org/2005/gco}AbstractObject_Type
    _ElementMap.update({
        __has.name() : __has,
        __partOf.name() : __partOf
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.DS_DataSet_Type = DS_DataSet_Type
_Namespace_gmd.addCategoryObject('typeBinding', 'DS_DataSet_Type', DS_DataSet_Type)


# Complex type {http://www.isotc211.org/2005/gmd}MD_Metadata_Type with content type ELEMENT_ONLY
class MD_Metadata_Type (AbstractObject_Type):
    """Information about the metadata"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_Metadata_Type')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataEntity.xsd', 21, 1)
    _ElementMap = AbstractObject_Type._ElementMap.copy()
    _AttributeMap = AbstractObject_Type._AttributeMap.copy()
    # Base type is AbstractObject_Type
    
    # Element {http://www.isotc211.org/2005/gmd}fileIdentifier uses Python identifier fileIdentifier
    __fileIdentifier = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'fileIdentifier'), 'fileIdentifier', '__httpwww_isotc211_org2005gmd_MD_Metadata_Type_httpwww_isotc211_org2005gmdfileIdentifier', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataEntity.xsd', 28, 5), )

    
    fileIdentifier = property(__fileIdentifier.value, __fileIdentifier.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}language uses Python identifier language
    __language = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'language'), 'language', '__httpwww_isotc211_org2005gmd_MD_Metadata_Type_httpwww_isotc211_org2005gmdlanguage', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataEntity.xsd', 29, 5), )

    
    language = property(__language.value, __language.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}characterSet uses Python identifier characterSet
    __characterSet = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'characterSet'), 'characterSet', '__httpwww_isotc211_org2005gmd_MD_Metadata_Type_httpwww_isotc211_org2005gmdcharacterSet', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataEntity.xsd', 30, 5), )

    
    characterSet = property(__characterSet.value, __characterSet.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}parentIdentifier uses Python identifier parentIdentifier
    __parentIdentifier = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'parentIdentifier'), 'parentIdentifier', '__httpwww_isotc211_org2005gmd_MD_Metadata_Type_httpwww_isotc211_org2005gmdparentIdentifier', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataEntity.xsd', 31, 5), )

    
    parentIdentifier = property(__parentIdentifier.value, __parentIdentifier.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}hierarchyLevel uses Python identifier hierarchyLevel
    __hierarchyLevel = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'hierarchyLevel'), 'hierarchyLevel', '__httpwww_isotc211_org2005gmd_MD_Metadata_Type_httpwww_isotc211_org2005gmdhierarchyLevel', True, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataEntity.xsd', 32, 5), )

    
    hierarchyLevel = property(__hierarchyLevel.value, __hierarchyLevel.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}hierarchyLevelName uses Python identifier hierarchyLevelName
    __hierarchyLevelName = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'hierarchyLevelName'), 'hierarchyLevelName', '__httpwww_isotc211_org2005gmd_MD_Metadata_Type_httpwww_isotc211_org2005gmdhierarchyLevelName', True, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataEntity.xsd', 33, 5), )

    
    hierarchyLevelName = property(__hierarchyLevelName.value, __hierarchyLevelName.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}contact uses Python identifier contact
    __contact = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'contact'), 'contact', '__httpwww_isotc211_org2005gmd_MD_Metadata_Type_httpwww_isotc211_org2005gmdcontact', True, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataEntity.xsd', 34, 5), )

    
    contact = property(__contact.value, __contact.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}dateStamp uses Python identifier dateStamp
    __dateStamp = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'dateStamp'), 'dateStamp', '__httpwww_isotc211_org2005gmd_MD_Metadata_Type_httpwww_isotc211_org2005gmddateStamp', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataEntity.xsd', 35, 5), )

    
    dateStamp = property(__dateStamp.value, __dateStamp.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}metadataStandardName uses Python identifier metadataStandardName
    __metadataStandardName = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'metadataStandardName'), 'metadataStandardName', '__httpwww_isotc211_org2005gmd_MD_Metadata_Type_httpwww_isotc211_org2005gmdmetadataStandardName', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataEntity.xsd', 36, 5), )

    
    metadataStandardName = property(__metadataStandardName.value, __metadataStandardName.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}metadataStandardVersion uses Python identifier metadataStandardVersion
    __metadataStandardVersion = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'metadataStandardVersion'), 'metadataStandardVersion', '__httpwww_isotc211_org2005gmd_MD_Metadata_Type_httpwww_isotc211_org2005gmdmetadataStandardVersion', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataEntity.xsd', 37, 5), )

    
    metadataStandardVersion = property(__metadataStandardVersion.value, __metadataStandardVersion.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}dataSetURI uses Python identifier dataSetURI
    __dataSetURI = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'dataSetURI'), 'dataSetURI', '__httpwww_isotc211_org2005gmd_MD_Metadata_Type_httpwww_isotc211_org2005gmddataSetURI', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataEntity.xsd', 38, 5), )

    
    dataSetURI = property(__dataSetURI.value, __dataSetURI.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}locale uses Python identifier locale
    __locale = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'locale'), 'locale', '__httpwww_isotc211_org2005gmd_MD_Metadata_Type_httpwww_isotc211_org2005gmdlocale', True, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataEntity.xsd', 39, 5), )

    
    locale = property(__locale.value, __locale.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}spatialRepresentationInfo uses Python identifier spatialRepresentationInfo
    __spatialRepresentationInfo = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'spatialRepresentationInfo'), 'spatialRepresentationInfo', '__httpwww_isotc211_org2005gmd_MD_Metadata_Type_httpwww_isotc211_org2005gmdspatialRepresentationInfo', True, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataEntity.xsd', 40, 5), )

    
    spatialRepresentationInfo = property(__spatialRepresentationInfo.value, __spatialRepresentationInfo.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}referenceSystemInfo uses Python identifier referenceSystemInfo
    __referenceSystemInfo = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'referenceSystemInfo'), 'referenceSystemInfo', '__httpwww_isotc211_org2005gmd_MD_Metadata_Type_httpwww_isotc211_org2005gmdreferenceSystemInfo', True, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataEntity.xsd', 41, 5), )

    
    referenceSystemInfo = property(__referenceSystemInfo.value, __referenceSystemInfo.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}metadataExtensionInfo uses Python identifier metadataExtensionInfo
    __metadataExtensionInfo = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'metadataExtensionInfo'), 'metadataExtensionInfo', '__httpwww_isotc211_org2005gmd_MD_Metadata_Type_httpwww_isotc211_org2005gmdmetadataExtensionInfo', True, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataEntity.xsd', 42, 5), )

    
    metadataExtensionInfo = property(__metadataExtensionInfo.value, __metadataExtensionInfo.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}identificationInfo uses Python identifier identificationInfo
    __identificationInfo = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'identificationInfo'), 'identificationInfo', '__httpwww_isotc211_org2005gmd_MD_Metadata_Type_httpwww_isotc211_org2005gmdidentificationInfo', True, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataEntity.xsd', 43, 5), )

    
    identificationInfo = property(__identificationInfo.value, __identificationInfo.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}contentInfo uses Python identifier contentInfo
    __contentInfo = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'contentInfo'), 'contentInfo', '__httpwww_isotc211_org2005gmd_MD_Metadata_Type_httpwww_isotc211_org2005gmdcontentInfo', True, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataEntity.xsd', 44, 5), )

    
    contentInfo = property(__contentInfo.value, __contentInfo.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}distributionInfo uses Python identifier distributionInfo
    __distributionInfo = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'distributionInfo'), 'distributionInfo', '__httpwww_isotc211_org2005gmd_MD_Metadata_Type_httpwww_isotc211_org2005gmddistributionInfo', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataEntity.xsd', 45, 5), )

    
    distributionInfo = property(__distributionInfo.value, __distributionInfo.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}dataQualityInfo uses Python identifier dataQualityInfo
    __dataQualityInfo = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'dataQualityInfo'), 'dataQualityInfo', '__httpwww_isotc211_org2005gmd_MD_Metadata_Type_httpwww_isotc211_org2005gmddataQualityInfo', True, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataEntity.xsd', 46, 5), )

    
    dataQualityInfo = property(__dataQualityInfo.value, __dataQualityInfo.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}portrayalCatalogueInfo uses Python identifier portrayalCatalogueInfo
    __portrayalCatalogueInfo = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'portrayalCatalogueInfo'), 'portrayalCatalogueInfo', '__httpwww_isotc211_org2005gmd_MD_Metadata_Type_httpwww_isotc211_org2005gmdportrayalCatalogueInfo', True, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataEntity.xsd', 47, 5), )

    
    portrayalCatalogueInfo = property(__portrayalCatalogueInfo.value, __portrayalCatalogueInfo.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}metadataConstraints uses Python identifier metadataConstraints
    __metadataConstraints = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'metadataConstraints'), 'metadataConstraints', '__httpwww_isotc211_org2005gmd_MD_Metadata_Type_httpwww_isotc211_org2005gmdmetadataConstraints', True, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataEntity.xsd', 48, 5), )

    
    metadataConstraints = property(__metadataConstraints.value, __metadataConstraints.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}applicationSchemaInfo uses Python identifier applicationSchemaInfo
    __applicationSchemaInfo = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'applicationSchemaInfo'), 'applicationSchemaInfo', '__httpwww_isotc211_org2005gmd_MD_Metadata_Type_httpwww_isotc211_org2005gmdapplicationSchemaInfo', True, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataEntity.xsd', 49, 5), )

    
    applicationSchemaInfo = property(__applicationSchemaInfo.value, __applicationSchemaInfo.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}metadataMaintenance uses Python identifier metadataMaintenance
    __metadataMaintenance = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'metadataMaintenance'), 'metadataMaintenance', '__httpwww_isotc211_org2005gmd_MD_Metadata_Type_httpwww_isotc211_org2005gmdmetadataMaintenance', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataEntity.xsd', 50, 5), )

    
    metadataMaintenance = property(__metadataMaintenance.value, __metadataMaintenance.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}series uses Python identifier series
    __series = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'series'), 'series', '__httpwww_isotc211_org2005gmd_MD_Metadata_Type_httpwww_isotc211_org2005gmdseries', True, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataEntity.xsd', 51, 5), )

    
    series = property(__series.value, __series.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}describes uses Python identifier describes
    __describes = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'describes'), 'describes', '__httpwww_isotc211_org2005gmd_MD_Metadata_Type_httpwww_isotc211_org2005gmddescribes', True, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataEntity.xsd', 52, 5), )

    
    describes = property(__describes.value, __describes.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}propertyType uses Python identifier propertyType
    __propertyType = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'propertyType'), 'propertyType', '__httpwww_isotc211_org2005gmd_MD_Metadata_Type_httpwww_isotc211_org2005gmdpropertyType', True, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataEntity.xsd', 53, 5), )

    
    propertyType = property(__propertyType.value, __propertyType.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}featureType uses Python identifier featureType
    __featureType = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'featureType'), 'featureType', '__httpwww_isotc211_org2005gmd_MD_Metadata_Type_httpwww_isotc211_org2005gmdfeatureType', True, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataEntity.xsd', 54, 5), )

    
    featureType = property(__featureType.value, __featureType.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}featureAttribute uses Python identifier featureAttribute
    __featureAttribute = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'featureAttribute'), 'featureAttribute', '__httpwww_isotc211_org2005gmd_MD_Metadata_Type_httpwww_isotc211_org2005gmdfeatureAttribute', True, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataEntity.xsd', 55, 5), )

    
    featureAttribute = property(__featureAttribute.value, __featureAttribute.set, None, None)

    
    # Attribute id inherited from {http://www.isotc211.org/2005/gco}AbstractObject_Type
    
    # Attribute uuid inherited from {http://www.isotc211.org/2005/gco}AbstractObject_Type
    _ElementMap.update({
        __fileIdentifier.name() : __fileIdentifier,
        __language.name() : __language,
        __characterSet.name() : __characterSet,
        __parentIdentifier.name() : __parentIdentifier,
        __hierarchyLevel.name() : __hierarchyLevel,
        __hierarchyLevelName.name() : __hierarchyLevelName,
        __contact.name() : __contact,
        __dateStamp.name() : __dateStamp,
        __metadataStandardName.name() : __metadataStandardName,
        __metadataStandardVersion.name() : __metadataStandardVersion,
        __dataSetURI.name() : __dataSetURI,
        __locale.name() : __locale,
        __spatialRepresentationInfo.name() : __spatialRepresentationInfo,
        __referenceSystemInfo.name() : __referenceSystemInfo,
        __metadataExtensionInfo.name() : __metadataExtensionInfo,
        __identificationInfo.name() : __identificationInfo,
        __contentInfo.name() : __contentInfo,
        __distributionInfo.name() : __distributionInfo,
        __dataQualityInfo.name() : __dataQualityInfo,
        __portrayalCatalogueInfo.name() : __portrayalCatalogueInfo,
        __metadataConstraints.name() : __metadataConstraints,
        __applicationSchemaInfo.name() : __applicationSchemaInfo,
        __metadataMaintenance.name() : __metadataMaintenance,
        __series.name() : __series,
        __describes.name() : __describes,
        __propertyType.name() : __propertyType,
        __featureType.name() : __featureType,
        __featureAttribute.name() : __featureAttribute
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.MD_Metadata_Type = MD_Metadata_Type
_Namespace_gmd.addCategoryObject('typeBinding', 'MD_Metadata_Type', MD_Metadata_Type)


# Complex type {http://www.isotc211.org/2005/gmd}MD_ExtendedElementInformation_Type with content type ELEMENT_ONLY
class MD_ExtendedElementInformation_Type (AbstractObject_Type):
    """New metadata element, not found in ISO 19115, which is required to describe geographic data"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_ExtendedElementInformation_Type')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataExtension.xsd', 14, 1)
    _ElementMap = AbstractObject_Type._ElementMap.copy()
    _AttributeMap = AbstractObject_Type._AttributeMap.copy()
    # Base type is AbstractObject_Type
    
    # Element {http://www.isotc211.org/2005/gmd}name uses Python identifier name
    __name = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'name'), 'name', '__httpwww_isotc211_org2005gmd_MD_ExtendedElementInformation_Type_httpwww_isotc211_org2005gmdname', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataExtension.xsd', 21, 5), )

    
    name = property(__name.value, __name.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}shortName uses Python identifier shortName
    __shortName = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'shortName'), 'shortName', '__httpwww_isotc211_org2005gmd_MD_ExtendedElementInformation_Type_httpwww_isotc211_org2005gmdshortName', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataExtension.xsd', 22, 5), )

    
    shortName = property(__shortName.value, __shortName.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}domainCode uses Python identifier domainCode
    __domainCode = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'domainCode'), 'domainCode', '__httpwww_isotc211_org2005gmd_MD_ExtendedElementInformation_Type_httpwww_isotc211_org2005gmddomainCode', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataExtension.xsd', 23, 5), )

    
    domainCode = property(__domainCode.value, __domainCode.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}definition uses Python identifier definition
    __definition = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'definition'), 'definition', '__httpwww_isotc211_org2005gmd_MD_ExtendedElementInformation_Type_httpwww_isotc211_org2005gmddefinition', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataExtension.xsd', 24, 5), )

    
    definition = property(__definition.value, __definition.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}obligation uses Python identifier obligation
    __obligation = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'obligation'), 'obligation', '__httpwww_isotc211_org2005gmd_MD_ExtendedElementInformation_Type_httpwww_isotc211_org2005gmdobligation', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataExtension.xsd', 25, 5), )

    
    obligation = property(__obligation.value, __obligation.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}condition uses Python identifier condition
    __condition = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'condition'), 'condition', '__httpwww_isotc211_org2005gmd_MD_ExtendedElementInformation_Type_httpwww_isotc211_org2005gmdcondition', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataExtension.xsd', 26, 5), )

    
    condition = property(__condition.value, __condition.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}dataType uses Python identifier dataType
    __dataType = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'dataType'), 'dataType', '__httpwww_isotc211_org2005gmd_MD_ExtendedElementInformation_Type_httpwww_isotc211_org2005gmddataType', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataExtension.xsd', 27, 5), )

    
    dataType = property(__dataType.value, __dataType.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}maximumOccurrence uses Python identifier maximumOccurrence
    __maximumOccurrence = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'maximumOccurrence'), 'maximumOccurrence', '__httpwww_isotc211_org2005gmd_MD_ExtendedElementInformation_Type_httpwww_isotc211_org2005gmdmaximumOccurrence', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataExtension.xsd', 28, 5), )

    
    maximumOccurrence = property(__maximumOccurrence.value, __maximumOccurrence.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}domainValue uses Python identifier domainValue
    __domainValue = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'domainValue'), 'domainValue', '__httpwww_isotc211_org2005gmd_MD_ExtendedElementInformation_Type_httpwww_isotc211_org2005gmddomainValue', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataExtension.xsd', 29, 5), )

    
    domainValue = property(__domainValue.value, __domainValue.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}parentEntity uses Python identifier parentEntity
    __parentEntity = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'parentEntity'), 'parentEntity', '__httpwww_isotc211_org2005gmd_MD_ExtendedElementInformation_Type_httpwww_isotc211_org2005gmdparentEntity', True, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataExtension.xsd', 30, 5), )

    
    parentEntity = property(__parentEntity.value, __parentEntity.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}rule uses Python identifier rule
    __rule = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'rule'), 'rule', '__httpwww_isotc211_org2005gmd_MD_ExtendedElementInformation_Type_httpwww_isotc211_org2005gmdrule', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataExtension.xsd', 31, 5), )

    
    rule = property(__rule.value, __rule.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}rationale uses Python identifier rationale
    __rationale = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'rationale'), 'rationale', '__httpwww_isotc211_org2005gmd_MD_ExtendedElementInformation_Type_httpwww_isotc211_org2005gmdrationale', True, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataExtension.xsd', 32, 5), )

    
    rationale = property(__rationale.value, __rationale.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}source uses Python identifier source
    __source = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'source'), 'source', '__httpwww_isotc211_org2005gmd_MD_ExtendedElementInformation_Type_httpwww_isotc211_org2005gmdsource', True, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataExtension.xsd', 33, 5), )

    
    source = property(__source.value, __source.set, None, None)

    
    # Attribute id inherited from {http://www.isotc211.org/2005/gco}AbstractObject_Type
    
    # Attribute uuid inherited from {http://www.isotc211.org/2005/gco}AbstractObject_Type
    _ElementMap.update({
        __name.name() : __name,
        __shortName.name() : __shortName,
        __domainCode.name() : __domainCode,
        __definition.name() : __definition,
        __obligation.name() : __obligation,
        __condition.name() : __condition,
        __dataType.name() : __dataType,
        __maximumOccurrence.name() : __maximumOccurrence,
        __domainValue.name() : __domainValue,
        __parentEntity.name() : __parentEntity,
        __rule.name() : __rule,
        __rationale.name() : __rationale,
        __source.name() : __source
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.MD_ExtendedElementInformation_Type = MD_ExtendedElementInformation_Type
_Namespace_gmd.addCategoryObject('typeBinding', 'MD_ExtendedElementInformation_Type', MD_ExtendedElementInformation_Type)


# Complex type {http://www.isotc211.org/2005/gmd}MD_MetadataExtensionInformation_Type with content type ELEMENT_ONLY
class MD_MetadataExtensionInformation_Type (AbstractObject_Type):
    """Information describing metadata extensions."""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_MetadataExtensionInformation_Type')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataExtension.xsd', 49, 1)
    _ElementMap = AbstractObject_Type._ElementMap.copy()
    _AttributeMap = AbstractObject_Type._AttributeMap.copy()
    # Base type is AbstractObject_Type
    
    # Element {http://www.isotc211.org/2005/gmd}extensionOnLineResource uses Python identifier extensionOnLineResource
    __extensionOnLineResource = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'extensionOnLineResource'), 'extensionOnLineResource', '__httpwww_isotc211_org2005gmd_MD_MetadataExtensionInformation_Type_httpwww_isotc211_org2005gmdextensionOnLineResource', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataExtension.xsd', 56, 5), )

    
    extensionOnLineResource = property(__extensionOnLineResource.value, __extensionOnLineResource.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}extendedElementInformation uses Python identifier extendedElementInformation
    __extendedElementInformation = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'extendedElementInformation'), 'extendedElementInformation', '__httpwww_isotc211_org2005gmd_MD_MetadataExtensionInformation_Type_httpwww_isotc211_org2005gmdextendedElementInformation', True, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataExtension.xsd', 57, 5), )

    
    extendedElementInformation = property(__extendedElementInformation.value, __extendedElementInformation.set, None, None)

    
    # Attribute id inherited from {http://www.isotc211.org/2005/gco}AbstractObject_Type
    
    # Attribute uuid inherited from {http://www.isotc211.org/2005/gco}AbstractObject_Type
    _ElementMap.update({
        __extensionOnLineResource.name() : __extensionOnLineResource,
        __extendedElementInformation.name() : __extendedElementInformation
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.MD_MetadataExtensionInformation_Type = MD_MetadataExtensionInformation_Type
_Namespace_gmd.addCategoryObject('typeBinding', 'MD_MetadataExtensionInformation_Type', MD_MetadataExtensionInformation_Type)


# Complex type {http://www.isotc211.org/2005/gmd}MD_PortrayalCatalogueReference_Type with content type ELEMENT_ONLY
class MD_PortrayalCatalogueReference_Type (AbstractObject_Type):
    """Information identifing the portrayal catalogue used"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_PortrayalCatalogueReference_Type')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/portrayalCatalogue.xsd', 14, 1)
    _ElementMap = AbstractObject_Type._ElementMap.copy()
    _AttributeMap = AbstractObject_Type._AttributeMap.copy()
    # Base type is AbstractObject_Type
    
    # Element {http://www.isotc211.org/2005/gmd}portrayalCatalogueCitation uses Python identifier portrayalCatalogueCitation
    __portrayalCatalogueCitation = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'portrayalCatalogueCitation'), 'portrayalCatalogueCitation', '__httpwww_isotc211_org2005gmd_MD_PortrayalCatalogueReference_Type_httpwww_isotc211_org2005gmdportrayalCatalogueCitation', True, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/portrayalCatalogue.xsd', 21, 5), )

    
    portrayalCatalogueCitation = property(__portrayalCatalogueCitation.value, __portrayalCatalogueCitation.set, None, None)

    
    # Attribute id inherited from {http://www.isotc211.org/2005/gco}AbstractObject_Type
    
    # Attribute uuid inherited from {http://www.isotc211.org/2005/gco}AbstractObject_Type
    _ElementMap.update({
        __portrayalCatalogueCitation.name() : __portrayalCatalogueCitation
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.MD_PortrayalCatalogueReference_Type = MD_PortrayalCatalogueReference_Type
_Namespace_gmd.addCategoryObject('typeBinding', 'MD_PortrayalCatalogueReference_Type', MD_PortrayalCatalogueReference_Type)


# Complex type {http://www.isotc211.org/2005/gmd}MD_ReferenceSystem_Type with content type ELEMENT_ONLY
class MD_ReferenceSystem_Type (AbstractObject_Type):
    """Complex type {http://www.isotc211.org/2005/gmd}MD_ReferenceSystem_Type with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_ReferenceSystem_Type')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/referenceSystem.xsd', 36, 1)
    _ElementMap = AbstractObject_Type._ElementMap.copy()
    _AttributeMap = AbstractObject_Type._AttributeMap.copy()
    # Base type is AbstractObject_Type
    
    # Element {http://www.isotc211.org/2005/gmd}referenceSystemIdentifier uses Python identifier referenceSystemIdentifier
    __referenceSystemIdentifier = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'referenceSystemIdentifier'), 'referenceSystemIdentifier', '__httpwww_isotc211_org2005gmd_MD_ReferenceSystem_Type_httpwww_isotc211_org2005gmdreferenceSystemIdentifier', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/referenceSystem.xsd', 40, 5), )

    
    referenceSystemIdentifier = property(__referenceSystemIdentifier.value, __referenceSystemIdentifier.set, None, None)

    
    # Attribute id inherited from {http://www.isotc211.org/2005/gco}AbstractObject_Type
    
    # Attribute uuid inherited from {http://www.isotc211.org/2005/gco}AbstractObject_Type
    _ElementMap.update({
        __referenceSystemIdentifier.name() : __referenceSystemIdentifier
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.MD_ReferenceSystem_Type = MD_ReferenceSystem_Type
_Namespace_gmd.addCategoryObject('typeBinding', 'MD_ReferenceSystem_Type', MD_ReferenceSystem_Type)


# Complex type {http://www.isotc211.org/2005/gmd}MD_Identifier_Type with content type ELEMENT_ONLY
class MD_Identifier_Type (AbstractObject_Type):
    """Complex type {http://www.isotc211.org/2005/gmd}MD_Identifier_Type with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_Identifier_Type')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/referenceSystem.xsd', 56, 1)
    _ElementMap = AbstractObject_Type._ElementMap.copy()
    _AttributeMap = AbstractObject_Type._AttributeMap.copy()
    # Base type is AbstractObject_Type
    
    # Element {http://www.isotc211.org/2005/gmd}authority uses Python identifier authority
    __authority = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'authority'), 'authority', '__httpwww_isotc211_org2005gmd_MD_Identifier_Type_httpwww_isotc211_org2005gmdauthority', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/referenceSystem.xsd', 60, 5), )

    
    authority = property(__authority.value, __authority.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}code uses Python identifier code
    __code = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'code'), 'code', '__httpwww_isotc211_org2005gmd_MD_Identifier_Type_httpwww_isotc211_org2005gmdcode', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/referenceSystem.xsd', 61, 5), )

    
    code = property(__code.value, __code.set, None, None)

    
    # Attribute id inherited from {http://www.isotc211.org/2005/gco}AbstractObject_Type
    
    # Attribute uuid inherited from {http://www.isotc211.org/2005/gco}AbstractObject_Type
    _ElementMap.update({
        __authority.name() : __authority,
        __code.name() : __code
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.MD_Identifier_Type = MD_Identifier_Type
_Namespace_gmd.addCategoryObject('typeBinding', 'MD_Identifier_Type', MD_Identifier_Type)


# Complex type {http://www.isotc211.org/2005/gmd}AbstractRS_ReferenceSystem_Type with content type ELEMENT_ONLY
class AbstractRS_ReferenceSystem_Type (AbstractObject_Type):
    """Description of the spatial and temporal reference systems used in the dataset"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = True
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'AbstractRS_ReferenceSystem_Type')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/referenceSystem.xsd', 77, 1)
    _ElementMap = AbstractObject_Type._ElementMap.copy()
    _AttributeMap = AbstractObject_Type._AttributeMap.copy()
    # Base type is AbstractObject_Type
    
    # Element {http://www.isotc211.org/2005/gmd}name uses Python identifier name
    __name = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'name'), 'name', '__httpwww_isotc211_org2005gmd_AbstractRS_ReferenceSystem_Type_httpwww_isotc211_org2005gmdname', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/referenceSystem.xsd', 84, 5), )

    
    name = property(__name.value, __name.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}domainOfValidity uses Python identifier domainOfValidity
    __domainOfValidity = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'domainOfValidity'), 'domainOfValidity', '__httpwww_isotc211_org2005gmd_AbstractRS_ReferenceSystem_Type_httpwww_isotc211_org2005gmddomainOfValidity', True, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/referenceSystem.xsd', 85, 5), )

    
    domainOfValidity = property(__domainOfValidity.value, __domainOfValidity.set, None, None)

    
    # Attribute id inherited from {http://www.isotc211.org/2005/gco}AbstractObject_Type
    
    # Attribute uuid inherited from {http://www.isotc211.org/2005/gco}AbstractObject_Type
    _ElementMap.update({
        __name.name() : __name,
        __domainOfValidity.name() : __domainOfValidity
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.AbstractRS_ReferenceSystem_Type = AbstractRS_ReferenceSystem_Type
_Namespace_gmd.addCategoryObject('typeBinding', 'AbstractRS_ReferenceSystem_Type', AbstractRS_ReferenceSystem_Type)


# Complex type {http://www.isotc211.org/2005/gmd}AbstractMD_SpatialRepresentation_Type with content type EMPTY
class AbstractMD_SpatialRepresentation_Type (AbstractObject_Type):
    """Digital mechanism used to represent spatial information"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_EMPTY
    _Abstract = True
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'AbstractMD_SpatialRepresentation_Type')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/spatialRepresentation.xsd', 65, 1)
    _ElementMap = AbstractObject_Type._ElementMap.copy()
    _AttributeMap = AbstractObject_Type._AttributeMap.copy()
    # Base type is AbstractObject_Type
    
    # Attribute id inherited from {http://www.isotc211.org/2005/gco}AbstractObject_Type
    
    # Attribute uuid inherited from {http://www.isotc211.org/2005/gco}AbstractObject_Type
    _ElementMap.update({
        
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.AbstractMD_SpatialRepresentation_Type = AbstractMD_SpatialRepresentation_Type
_Namespace_gmd.addCategoryObject('typeBinding', 'AbstractMD_SpatialRepresentation_Type', AbstractMD_SpatialRepresentation_Type)


# Complex type {http://www.isotc211.org/2005/gmd}MD_Dimension_Type with content type ELEMENT_ONLY
class MD_Dimension_Type (AbstractObject_Type):
    """Complex type {http://www.isotc211.org/2005/gmd}MD_Dimension_Type with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_Dimension_Type')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/spatialRepresentation.xsd', 110, 1)
    _ElementMap = AbstractObject_Type._ElementMap.copy()
    _AttributeMap = AbstractObject_Type._AttributeMap.copy()
    # Base type is AbstractObject_Type
    
    # Element {http://www.isotc211.org/2005/gmd}dimensionName uses Python identifier dimensionName
    __dimensionName = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'dimensionName'), 'dimensionName', '__httpwww_isotc211_org2005gmd_MD_Dimension_Type_httpwww_isotc211_org2005gmddimensionName', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/spatialRepresentation.xsd', 114, 5), )

    
    dimensionName = property(__dimensionName.value, __dimensionName.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}dimensionSize uses Python identifier dimensionSize
    __dimensionSize = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'dimensionSize'), 'dimensionSize', '__httpwww_isotc211_org2005gmd_MD_Dimension_Type_httpwww_isotc211_org2005gmddimensionSize', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/spatialRepresentation.xsd', 115, 5), )

    
    dimensionSize = property(__dimensionSize.value, __dimensionSize.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}resolution uses Python identifier resolution
    __resolution = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'resolution'), 'resolution', '__httpwww_isotc211_org2005gmd_MD_Dimension_Type_httpwww_isotc211_org2005gmdresolution', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/spatialRepresentation.xsd', 116, 5), )

    
    resolution = property(__resolution.value, __resolution.set, None, None)

    
    # Attribute id inherited from {http://www.isotc211.org/2005/gco}AbstractObject_Type
    
    # Attribute uuid inherited from {http://www.isotc211.org/2005/gco}AbstractObject_Type
    _ElementMap.update({
        __dimensionName.name() : __dimensionName,
        __dimensionSize.name() : __dimensionSize,
        __resolution.name() : __resolution
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.MD_Dimension_Type = MD_Dimension_Type
_Namespace_gmd.addCategoryObject('typeBinding', 'MD_Dimension_Type', MD_Dimension_Type)


# Complex type {http://www.isotc211.org/2005/gmd}MD_GeometricObjects_Type with content type ELEMENT_ONLY
class MD_GeometricObjects_Type (AbstractObject_Type):
    """Complex type {http://www.isotc211.org/2005/gmd}MD_GeometricObjects_Type with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_GeometricObjects_Type')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/spatialRepresentation.xsd', 158, 1)
    _ElementMap = AbstractObject_Type._ElementMap.copy()
    _AttributeMap = AbstractObject_Type._AttributeMap.copy()
    # Base type is AbstractObject_Type
    
    # Element {http://www.isotc211.org/2005/gmd}geometricObjectType uses Python identifier geometricObjectType
    __geometricObjectType = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'geometricObjectType'), 'geometricObjectType', '__httpwww_isotc211_org2005gmd_MD_GeometricObjects_Type_httpwww_isotc211_org2005gmdgeometricObjectType', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/spatialRepresentation.xsd', 162, 5), )

    
    geometricObjectType = property(__geometricObjectType.value, __geometricObjectType.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}geometricObjectCount uses Python identifier geometricObjectCount
    __geometricObjectCount = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'geometricObjectCount'), 'geometricObjectCount', '__httpwww_isotc211_org2005gmd_MD_GeometricObjects_Type_httpwww_isotc211_org2005gmdgeometricObjectCount', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/spatialRepresentation.xsd', 163, 5), )

    
    geometricObjectCount = property(__geometricObjectCount.value, __geometricObjectCount.set, None, None)

    
    # Attribute id inherited from {http://www.isotc211.org/2005/gco}AbstractObject_Type
    
    # Attribute uuid inherited from {http://www.isotc211.org/2005/gco}AbstractObject_Type
    _ElementMap.update({
        __geometricObjectType.name() : __geometricObjectType,
        __geometricObjectCount.name() : __geometricObjectCount
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.MD_GeometricObjects_Type = MD_GeometricObjects_Type
_Namespace_gmd.addCategoryObject('typeBinding', 'MD_GeometricObjects_Type', MD_GeometricObjects_Type)


# Complex type {http://www.opengis.net/gml/3.2}CodeWithAuthorityType with content type SIMPLE
class CodeWithAuthorityType (CodeType):
    """gml:CodeWithAuthorityType requires that the codeSpace attribute is provided in an instance."""
    _TypeDefinition = STD_ANON_2
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_SIMPLE
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'CodeWithAuthorityType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/basicTypes.xsd', 103, 1)
    _ElementMap = CodeType._ElementMap.copy()
    _AttributeMap = CodeType._AttributeMap.copy()
    # Base type is CodeType
    
    # Attribute codeSpace is restricted from parent
    
    # Attribute codeSpace uses Python identifier codeSpace
    __codeSpace = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'codeSpace'), 'codeSpace', '__httpwww_opengis_netgml3_2_CodeType_codeSpace', pyxb.binding.datatypes.anyURI, required=True)
    __codeSpace._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/basicTypes.xsd', 109, 4)
    __codeSpace._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/basicTypes.xsd', 109, 4)
    
    codeSpace = property(__codeSpace.value, __codeSpace.set, None, None)

    _ElementMap.update({
        
    })
    _AttributeMap.update({
        __codeSpace.name() : __codeSpace
    })
_module_typeBindings.CodeWithAuthorityType = CodeWithAuthorityType
_Namespace_gml.addCategoryObject('typeBinding', 'CodeWithAuthorityType', CodeWithAuthorityType)


# Complex type {http://www.opengis.net/gml/3.2}CodeListType with content type SIMPLE
class CodeListType (pyxb.binding.basis.complexTypeDefinition):
    """gml:CodeListType provides for lists of terms. The values in an instance element shall all be valid according to the rules of the dictionary, classification scheme, or authority identified by the value of its codeSpace attribute."""
    _TypeDefinition = NameList
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_SIMPLE
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'CodeListType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/basicTypes.xsd', 228, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is NameList
    
    # Attribute codeSpace uses Python identifier codeSpace
    __codeSpace = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'codeSpace'), 'codeSpace', '__httpwww_opengis_netgml3_2_CodeListType_codeSpace', pyxb.binding.datatypes.anyURI)
    __codeSpace._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/basicTypes.xsd', 234, 4)
    __codeSpace._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/basicTypes.xsd', 234, 4)
    
    codeSpace = property(__codeSpace.value, __codeSpace.set, None, None)

    _ElementMap.update({
        
    })
    _AttributeMap.update({
        __codeSpace.name() : __codeSpace
    })
_module_typeBindings.CodeListType = CodeListType
_Namespace_gml.addCategoryObject('typeBinding', 'CodeListType', CodeListType)


# Complex type {http://www.opengis.net/gml/3.2}ParameterValueType with content type ELEMENT_ONLY
class ParameterValueType (AbstractGeneralParameterValueType):
    """Complex type {http://www.opengis.net/gml/3.2}ParameterValueType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'ParameterValueType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 305, 1)
    _ElementMap = AbstractGeneralParameterValueType._ElementMap.copy()
    _AttributeMap = AbstractGeneralParameterValueType._AttributeMap.copy()
    # Base type is AbstractGeneralParameterValueType
    
    # Element {http://www.opengis.net/gml/3.2}value uses Python identifier value_
    __value = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'value'), 'value_', '__httpwww_opengis_netgml3_2_ParameterValueType_httpwww_opengis_netgml3_2value', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 324, 1), )

    
    value_ = property(__value.value, __value.set, None, 'gml:value is a numeric value of an operation parameter, with its associated unit of measure.')

    
    # Element {http://www.opengis.net/gml/3.2}stringValue uses Python identifier stringValue
    __stringValue = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'stringValue'), 'stringValue', '__httpwww_opengis_netgml3_2_ParameterValueType_httpwww_opengis_netgml3_2stringValue', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 329, 1), )

    
    stringValue = property(__stringValue.value, __stringValue.set, None, 'gml:stringValue is a character string value of an operation parameter. A string value does not have an associated unit of measure.')

    
    # Element {http://www.opengis.net/gml/3.2}integerValue uses Python identifier integerValue
    __integerValue = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'integerValue'), 'integerValue', '__httpwww_opengis_netgml3_2_ParameterValueType_httpwww_opengis_netgml3_2integerValue', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 334, 1), )

    
    integerValue = property(__integerValue.value, __integerValue.set, None, 'gml:integerValue is a positive integer value of an operation parameter, usually used for a count. An integer value does not have an associated unit of measure.')

    
    # Element {http://www.opengis.net/gml/3.2}booleanValue uses Python identifier booleanValue
    __booleanValue = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'booleanValue'), 'booleanValue', '__httpwww_opengis_netgml3_2_ParameterValueType_httpwww_opengis_netgml3_2booleanValue', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 339, 1), )

    
    booleanValue = property(__booleanValue.value, __booleanValue.set, None, 'gml:booleanValue is a boolean value of an operation parameter. A Boolean value does not have an associated unit of measure.')

    
    # Element {http://www.opengis.net/gml/3.2}valueList uses Python identifier valueList
    __valueList = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'valueList'), 'valueList', '__httpwww_opengis_netgml3_2_ParameterValueType_httpwww_opengis_netgml3_2valueList', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 344, 1), )

    
    valueList = property(__valueList.value, __valueList.set, None, 'gml:valueList is an ordered sequence of two or more numeric values of an operation parameter list, where each value has the same associated unit of measure. An element of this type contains a space-separated sequence of double values.')

    
    # Element {http://www.opengis.net/gml/3.2}integerValueList uses Python identifier integerValueList
    __integerValueList = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'integerValueList'), 'integerValueList', '__httpwww_opengis_netgml3_2_ParameterValueType_httpwww_opengis_netgml3_2integerValueList', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 349, 1), )

    
    integerValueList = property(__integerValueList.value, __integerValueList.set, None, 'gml:integerValueList is an ordered sequence of two or more integer values of an operation parameter list, usually used for counts. These integer values do not have an associated unit of measure. An element of this type contains a space-separated sequence of integer values.')

    
    # Element {http://www.opengis.net/gml/3.2}valueFile uses Python identifier valueFile
    __valueFile = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'valueFile'), 'valueFile', '__httpwww_opengis_netgml3_2_ParameterValueType_httpwww_opengis_netgml3_2valueFile', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 354, 1), )

    
    valueFile = property(__valueFile.value, __valueFile.set, None, 'gml:valueFile is a reference to a file or a part of a file containing one or more parameter values, each numeric value with its associated unit of measure. When referencing a part of a file, that file shall contain multiple identified parts, such as an XML encoded document. Furthermore, the referenced file or part of a file may reference another part of the same or different files, as allowed in XML documents.')

    
    # Element {http://www.opengis.net/gml/3.2}operationParameter uses Python identifier operationParameter
    __operationParameter = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'operationParameter'), 'operationParameter', '__httpwww_opengis_netgml3_2_ParameterValueType_httpwww_opengis_netgml3_2operationParameter', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 359, 1), )

    
    operationParameter = property(__operationParameter.value, __operationParameter.set, None, 'gml:operationParameter is an association role to the operation parameter of which this is a value.')

    
    # Element {http://www.opengis.net/gml/3.2}dmsAngleValue uses Python identifier dmsAngleValue
    __dmsAngleValue = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'dmsAngleValue'), 'dmsAngleValue', '__httpwww_opengis_netgml3_2_ParameterValueType_httpwww_opengis_netgml3_2dmsAngleValue', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 152, 1), )

    
    dmsAngleValue = property(__dmsAngleValue.value, __dmsAngleValue.set, None, '')

    _ElementMap.update({
        __value.name() : __value,
        __stringValue.name() : __stringValue,
        __integerValue.name() : __integerValue,
        __booleanValue.name() : __booleanValue,
        __valueList.name() : __valueList,
        __integerValueList.name() : __integerValueList,
        __valueFile.name() : __valueFile,
        __operationParameter.name() : __operationParameter,
        __dmsAngleValue.name() : __dmsAngleValue
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.ParameterValueType = ParameterValueType
_Namespace_gml.addCategoryObject('typeBinding', 'ParameterValueType', ParameterValueType)


# Complex type {http://www.opengis.net/gml/3.2}ParameterValueGroupType with content type ELEMENT_ONLY
class ParameterValueGroupType (AbstractGeneralParameterValueType):
    """Complex type {http://www.opengis.net/gml/3.2}ParameterValueGroupType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'ParameterValueGroupType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 370, 1)
    _ElementMap = AbstractGeneralParameterValueType._ElementMap.copy()
    _AttributeMap = AbstractGeneralParameterValueType._AttributeMap.copy()
    # Base type is AbstractGeneralParameterValueType
    
    # Element {http://www.opengis.net/gml/3.2}parameterValue uses Python identifier parameterValue
    __parameterValue = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'parameterValue'), 'parameterValue', '__httpwww_opengis_netgml3_2_ParameterValueGroupType_httpwww_opengis_netgml3_2parameterValue', True, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 243, 1), )

    
    parameterValue = property(__parameterValue.value, __parameterValue.set, None, 'gml:parameterValue is a composition association to a parameter value or group of parameter values used by a coordinate operation.')

    
    # Element {http://www.opengis.net/gml/3.2}group uses Python identifier group
    __group = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'group'), 'group', '__httpwww_opengis_netgml3_2_ParameterValueGroupType_httpwww_opengis_netgml3_2group', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 380, 1), )

    
    group = property(__group.value, __group.set, None, 'gml:group is an association role to the operation parameter group for which this element provides parameter values.')

    _ElementMap.update({
        __parameterValue.name() : __parameterValue,
        __group.name() : __group
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.ParameterValueGroupType = ParameterValueGroupType
_Namespace_gml.addCategoryObject('typeBinding', 'ParameterValueGroupType', ParameterValueGroupType)


# Complex type {http://www.opengis.net/gml/3.2}DegreesType with content type SIMPLE
class DegreesType (pyxb.binding.basis.complexTypeDefinition):
    """"""
    _TypeDefinition = DegreeValueType
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_SIMPLE
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'DegreesType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 559, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is DegreeValueType
    
    # Attribute direction uses Python identifier direction
    __direction = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'direction'), 'direction', '__httpwww_opengis_netgml3_2_DegreesType_direction', _module_typeBindings.STD_ANON_3)
    __direction._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 565, 4)
    __direction._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 565, 4)
    
    direction = property(__direction.value, __direction.set, None, None)

    _ElementMap.update({
        
    })
    _AttributeMap.update({
        __direction.name() : __direction
    })
_module_typeBindings.DegreesType = DegreesType
_Namespace_gml.addCategoryObject('typeBinding', 'DegreesType', DegreesType)


# Complex type {http://www.opengis.net/gml/3.2}BagType with content type ELEMENT_ONLY
class BagType (AbstractGMLType):
    """"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'BagType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 682, 1)
    _ElementMap = AbstractGMLType._ElementMap.copy()
    _AttributeMap = AbstractGMLType._AttributeMap.copy()
    # Base type is AbstractGMLType
    
    # Element {http://www.opengis.net/gml/3.2}member uses Python identifier member
    __member = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'member'), 'member', '__httpwww_opengis_netgml3_2_BagType_httpwww_opengis_netgml3_2member', True, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 643, 1), )

    
    member = property(__member.value, __member.set, None, '')

    
    # Element {http://www.opengis.net/gml/3.2}members uses Python identifier members
    __members = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'members'), 'members', '__httpwww_opengis_netgml3_2_BagType_httpwww_opengis_netgml3_2members', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 657, 1), )

    
    members = property(__members.value, __members.set, None, '')

    
    # Element metaDataProperty ({http://www.opengis.net/gml/3.2}metaDataProperty) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element description ({http://www.opengis.net/gml/3.2}description) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element descriptionReference ({http://www.opengis.net/gml/3.2}descriptionReference) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element name ({http://www.opengis.net/gml/3.2}name) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element identifier ({http://www.opengis.net/gml/3.2}identifier) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Attribute id inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    _ElementMap.update({
        __member.name() : __member,
        __members.name() : __members
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.BagType = BagType
_Namespace_gml.addCategoryObject('typeBinding', 'BagType', BagType)


# Complex type {http://www.opengis.net/gml/3.2}ArrayType with content type ELEMENT_ONLY
class ArrayType (AbstractGMLType):
    """"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'ArrayType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 700, 1)
    _ElementMap = AbstractGMLType._ElementMap.copy()
    _AttributeMap = AbstractGMLType._AttributeMap.copy()
    # Base type is AbstractGMLType
    
    # Element {http://www.opengis.net/gml/3.2}members uses Python identifier members
    __members = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'members'), 'members', '__httpwww_opengis_netgml3_2_ArrayType_httpwww_opengis_netgml3_2members', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 657, 1), )

    
    members = property(__members.value, __members.set, None, '')

    
    # Element metaDataProperty ({http://www.opengis.net/gml/3.2}metaDataProperty) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element description ({http://www.opengis.net/gml/3.2}description) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element descriptionReference ({http://www.opengis.net/gml/3.2}descriptionReference) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element name ({http://www.opengis.net/gml/3.2}name) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element identifier ({http://www.opengis.net/gml/3.2}identifier) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Attribute id inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    _ElementMap.update({
        __members.name() : __members
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.ArrayType = ArrayType
_Namespace_gml.addCategoryObject('typeBinding', 'ArrayType', ArrayType)


# Complex type {http://www.opengis.net/gml/3.2}GenericMetaDataType with content type MIXED
class GenericMetaDataType (AbstractMetaDataType):
    """"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_MIXED
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'GenericMetaDataType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 739, 1)
    _ElementMap = AbstractMetaDataType._ElementMap.copy()
    _AttributeMap = AbstractMetaDataType._AttributeMap.copy()
    # Base type is AbstractMetaDataType
    
    # Attribute id inherited from {http://www.opengis.net/gml/3.2}AbstractMetaDataType
    _HasWildcardElement = True
    _ElementMap.update({
        
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.GenericMetaDataType = GenericMetaDataType
_Namespace_gml.addCategoryObject('typeBinding', 'GenericMetaDataType', GenericMetaDataType)


# Complex type {http://www.opengis.net/gml/3.2}DefinitionBaseType with content type ELEMENT_ONLY
class DefinitionBaseType (AbstractGMLType):
    """Complex type {http://www.opengis.net/gml/3.2}DefinitionBaseType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'DefinitionBaseType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 31, 1)
    _ElementMap = AbstractGMLType._ElementMap.copy()
    _AttributeMap = AbstractGMLType._AttributeMap.copy()
    # Base type is AbstractGMLType
    
    # Element metaDataProperty ({http://www.opengis.net/gml/3.2}metaDataProperty) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element description ({http://www.opengis.net/gml/3.2}description) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element descriptionReference ({http://www.opengis.net/gml/3.2}descriptionReference) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element name ({http://www.opengis.net/gml/3.2}name) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element identifier ({http://www.opengis.net/gml/3.2}identifier) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Attribute id is restricted from parent
    
    # Attribute {http://www.opengis.net/gml/3.2}id uses Python identifier id
    __id = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gml, 'id'), 'id', '__httpwww_opengis_netgml3_2_AbstractGMLType_httpwww_opengis_netgml3_2id', pyxb.binding.datatypes.ID, required=True)
    __id._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 137, 1)
    __id._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 41, 4)
    
    id = property(__id.value, __id.set, None, 'The attribute gml:id supports provision of a handle for the XML element representing a GML Object. Its use is mandatory for all GML objects. It is of XML type ID, so is constrained to be unique in the XML document within which it occurs.')

    _ElementMap.update({
        
    })
    _AttributeMap.update({
        __id.name() : __id
    })
_module_typeBindings.DefinitionBaseType = DefinitionBaseType
_Namespace_gml.addCategoryObject('typeBinding', 'DefinitionBaseType', DefinitionBaseType)


# Complex type {http://www.opengis.net/gml/3.2}AbstractTimeSliceType with content type ELEMENT_ONLY
class AbstractTimeSliceType (AbstractGMLType):
    """Complex type {http://www.opengis.net/gml/3.2}AbstractTimeSliceType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = True
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractTimeSliceType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dynamicFeature.xsd', 87, 1)
    _ElementMap = AbstractGMLType._ElementMap.copy()
    _AttributeMap = AbstractGMLType._AttributeMap.copy()
    # Base type is AbstractGMLType
    
    # Element metaDataProperty ({http://www.opengis.net/gml/3.2}metaDataProperty) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element {http://www.opengis.net/gml/3.2}dataSource uses Python identifier dataSource
    __dataSource = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'dataSource'), 'dataSource', '__httpwww_opengis_netgml3_2_AbstractTimeSliceType_httpwww_opengis_netgml3_2dataSource', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dynamicFeature.xsd', 17, 1), )

    
    dataSource = property(__dataSource.value, __dataSource.set, None, 'Evidence is represented by a simple gml:dataSource or gml:dataSourceReference property that indicates the source of the temporal data. The remote link attributes of the gml:dataSource element have been deprecated along with its current type.')

    
    # Element description ({http://www.opengis.net/gml/3.2}description) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element descriptionReference ({http://www.opengis.net/gml/3.2}descriptionReference) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element name ({http://www.opengis.net/gml/3.2}name) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element identifier ({http://www.opengis.net/gml/3.2}identifier) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element {http://www.opengis.net/gml/3.2}validTime uses Python identifier validTime
    __validTime = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'validTime'), 'validTime', '__httpwww_opengis_netgml3_2_AbstractTimeSliceType_httpwww_opengis_netgml3_2validTime', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporal.xsd', 52, 1), )

    
    validTime = property(__validTime.value, __validTime.set, None, 'gml:validTime is a convenience property element.')

    
    # Attribute id inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    _ElementMap.update({
        __dataSource.name() : __dataSource,
        __validTime.name() : __validTime
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.AbstractTimeSliceType = AbstractTimeSliceType
_Namespace_gml.addCategoryObject('typeBinding', 'AbstractTimeSliceType', AbstractTimeSliceType)


# Complex type {http://www.opengis.net/gml/3.2}AbstractFeatureType with content type ELEMENT_ONLY
class AbstractFeatureType (AbstractGMLType):
    """The basic feature model is given by the gml:AbstractFeatureType.
The content model for gml:AbstractFeatureType adds two specific properties suitable for geographic features to the content model defined in gml:AbstractGMLType. 
The value of the gml:boundedBy property describes an envelope that encloses the entire feature instance, and is primarily useful for supporting rapid searching for features that occur in a particular location. 
The value of the gml:location property describes the extent, position or relative location of the feature."""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = True
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractFeatureType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/feature.xsd', 16, 1)
    _ElementMap = AbstractGMLType._ElementMap.copy()
    _AttributeMap = AbstractGMLType._AttributeMap.copy()
    # Base type is AbstractGMLType
    
    # Element metaDataProperty ({http://www.opengis.net/gml/3.2}metaDataProperty) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element {http://www.opengis.net/gml/3.2}location uses Python identifier location
    __location = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'location'), 'location', '__httpwww_opengis_netgml3_2_AbstractFeatureType_httpwww_opengis_netgml3_2location', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 761, 1), )

    
    location = property(__location.value, __location.set, None, '')

    
    # Element {http://www.opengis.net/gml/3.2}boundedBy uses Python identifier boundedBy
    __boundedBy = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'boundedBy'), 'boundedBy', '__httpwww_opengis_netgml3_2_AbstractFeatureType_httpwww_opengis_netgml3_2boundedBy', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/feature.xsd', 45, 1), )

    
    boundedBy = property(__boundedBy.value, __boundedBy.set, None, 'This property describes the minimum bounding box or rectangle that encloses the entire feature.')

    
    # Element description ({http://www.opengis.net/gml/3.2}description) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element descriptionReference ({http://www.opengis.net/gml/3.2}descriptionReference) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element name ({http://www.opengis.net/gml/3.2}name) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element identifier ({http://www.opengis.net/gml/3.2}identifier) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Attribute id inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    _ElementMap.update({
        __location.name() : __location,
        __boundedBy.name() : __boundedBy
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.AbstractFeatureType = AbstractFeatureType
_Namespace_gml.addCategoryObject('typeBinding', 'AbstractFeatureType', AbstractFeatureType)


# Complex type {http://www.opengis.net/gml/3.2}AbstractGeometryType with content type ELEMENT_ONLY
class AbstractGeometryType (AbstractGMLType):
    """All geometry elements are derived directly or indirectly from this abstract supertype. A geometry element may have an identifying attribute (gml:id), one or more names (elements identifier and name) and a description (elements description and descriptionReference) . It may be associated with a spatial reference system (attribute group gml:SRSReferenceGroup).
The following rules shall be adhered to:
-	Every geometry type shall derive from this abstract type.
-	Every geometry element (i.e. an element of a geometry type) shall be directly or indirectly in the substitution group of AbstractGeometry."""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = True
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractGeometryType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic0d1d.xsd', 18, 1)
    _ElementMap = AbstractGMLType._ElementMap.copy()
    _AttributeMap = AbstractGMLType._AttributeMap.copy()
    # Base type is AbstractGMLType
    
    # Element metaDataProperty ({http://www.opengis.net/gml/3.2}metaDataProperty) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element description ({http://www.opengis.net/gml/3.2}description) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element descriptionReference ({http://www.opengis.net/gml/3.2}descriptionReference) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element name ({http://www.opengis.net/gml/3.2}name) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element identifier ({http://www.opengis.net/gml/3.2}identifier) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Attribute srsName uses Python identifier srsName
    __srsName = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'srsName'), 'srsName', '__httpwww_opengis_netgml3_2_AbstractGeometryType_srsName', pyxb.binding.datatypes.anyURI)
    __srsName._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic0d1d.xsd', 37, 2)
    __srsName._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic0d1d.xsd', 37, 2)
    
    srsName = property(__srsName.value, __srsName.set, None, None)

    
    # Attribute srsDimension uses Python identifier srsDimension
    __srsDimension = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'srsDimension'), 'srsDimension', '__httpwww_opengis_netgml3_2_AbstractGeometryType_srsDimension', pyxb.binding.datatypes.positiveInteger)
    __srsDimension._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic0d1d.xsd', 38, 2)
    __srsDimension._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic0d1d.xsd', 38, 2)
    
    srsDimension = property(__srsDimension.value, __srsDimension.set, None, None)

    
    # Attribute axisLabels uses Python identifier axisLabels
    __axisLabels = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'axisLabels'), 'axisLabels', '__httpwww_opengis_netgml3_2_AbstractGeometryType_axisLabels', _module_typeBindings.NCNameList)
    __axisLabels._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic0d1d.xsd', 47, 2)
    __axisLabels._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic0d1d.xsd', 47, 2)
    
    axisLabels = property(__axisLabels.value, __axisLabels.set, None, None)

    
    # Attribute uomLabels uses Python identifier uomLabels
    __uomLabels = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'uomLabels'), 'uomLabels', '__httpwww_opengis_netgml3_2_AbstractGeometryType_uomLabels', _module_typeBindings.NCNameList)
    __uomLabels._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic0d1d.xsd', 48, 2)
    __uomLabels._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic0d1d.xsd', 48, 2)
    
    uomLabels = property(__uomLabels.value, __uomLabels.set, None, None)

    
    # Attribute id inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    _ElementMap.update({
        
    })
    _AttributeMap.update({
        __srsName.name() : __srsName,
        __srsDimension.name() : __srsDimension,
        __axisLabels.name() : __axisLabels,
        __uomLabels.name() : __uomLabels
    })
_module_typeBindings.AbstractGeometryType = AbstractGeometryType
_Namespace_gml.addCategoryObject('typeBinding', 'AbstractGeometryType', AbstractGeometryType)


# Complex type {http://www.opengis.net/gml/3.2}DirectPositionType with content type SIMPLE
class DirectPositionType (pyxb.binding.basis.complexTypeDefinition):
    """Direct position instances hold the coordinates for a position within some coordinate reference system (CRS). Since direct positions, as data types, will often be included in larger objects (such as geometry elements) that have references to CRS, the srsName attribute will in general be missing, if this particular direct position is included in a larger element with such a reference to a CRS. In this case, the CRS is implicitly assumed to take on the value of the containing object's CRS.
if no srsName attribute is given, the CRS shall be specified as part of the larger context this geometry element is part of, typically a geometric object like a point, curve, etc."""
    _TypeDefinition = doubleList
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_SIMPLE
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'DirectPositionType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic0d1d.xsd', 76, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is doubleList
    
    # Attribute srsName uses Python identifier srsName
    __srsName = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'srsName'), 'srsName', '__httpwww_opengis_netgml3_2_DirectPositionType_srsName', pyxb.binding.datatypes.anyURI)
    __srsName._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic0d1d.xsd', 37, 2)
    __srsName._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic0d1d.xsd', 37, 2)
    
    srsName = property(__srsName.value, __srsName.set, None, None)

    
    # Attribute srsDimension uses Python identifier srsDimension
    __srsDimension = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'srsDimension'), 'srsDimension', '__httpwww_opengis_netgml3_2_DirectPositionType_srsDimension', pyxb.binding.datatypes.positiveInteger)
    __srsDimension._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic0d1d.xsd', 38, 2)
    __srsDimension._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic0d1d.xsd', 38, 2)
    
    srsDimension = property(__srsDimension.value, __srsDimension.set, None, None)

    
    # Attribute axisLabels uses Python identifier axisLabels
    __axisLabels = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'axisLabels'), 'axisLabels', '__httpwww_opengis_netgml3_2_DirectPositionType_axisLabels', _module_typeBindings.NCNameList)
    __axisLabels._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic0d1d.xsd', 47, 2)
    __axisLabels._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic0d1d.xsd', 47, 2)
    
    axisLabels = property(__axisLabels.value, __axisLabels.set, None, None)

    
    # Attribute uomLabels uses Python identifier uomLabels
    __uomLabels = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'uomLabels'), 'uomLabels', '__httpwww_opengis_netgml3_2_DirectPositionType_uomLabels', _module_typeBindings.NCNameList)
    __uomLabels._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic0d1d.xsd', 48, 2)
    __uomLabels._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic0d1d.xsd', 48, 2)
    
    uomLabels = property(__uomLabels.value, __uomLabels.set, None, None)

    _ElementMap.update({
        
    })
    _AttributeMap.update({
        __srsName.name() : __srsName,
        __srsDimension.name() : __srsDimension,
        __axisLabels.name() : __axisLabels,
        __uomLabels.name() : __uomLabels
    })
_module_typeBindings.DirectPositionType = DirectPositionType
_Namespace_gml.addCategoryObject('typeBinding', 'DirectPositionType', DirectPositionType)


# Complex type {http://www.opengis.net/gml/3.2}DirectPositionListType with content type SIMPLE
class DirectPositionListType (pyxb.binding.basis.complexTypeDefinition):
    """posList instances (and other instances with the content model specified by DirectPositionListType) hold the coordinates for a sequence of direct positions within the same coordinate reference system (CRS).
if no srsName attribute is given, the CRS shall be specified as part of the larger context this geometry element is part of, typically a geometric object like a point, curve, etc. 
The optional attribute count specifies the number of direct positions in the list. If the attribute count is present then the attribute srsDimension shall be present, too.
The number of entries in the list is equal to the product of the dimensionality of the coordinate reference system (i.e. it is a derived value of the coordinate reference system definition) and the number of direct positions."""
    _TypeDefinition = doubleList
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_SIMPLE
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'DirectPositionListType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic0d1d.xsd', 88, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is doubleList
    
    # Attribute srsName uses Python identifier srsName
    __srsName = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'srsName'), 'srsName', '__httpwww_opengis_netgml3_2_DirectPositionListType_srsName', pyxb.binding.datatypes.anyURI)
    __srsName._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic0d1d.xsd', 37, 2)
    __srsName._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic0d1d.xsd', 37, 2)
    
    srsName = property(__srsName.value, __srsName.set, None, None)

    
    # Attribute srsDimension uses Python identifier srsDimension
    __srsDimension = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'srsDimension'), 'srsDimension', '__httpwww_opengis_netgml3_2_DirectPositionListType_srsDimension', pyxb.binding.datatypes.positiveInteger)
    __srsDimension._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic0d1d.xsd', 38, 2)
    __srsDimension._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic0d1d.xsd', 38, 2)
    
    srsDimension = property(__srsDimension.value, __srsDimension.set, None, None)

    
    # Attribute axisLabels uses Python identifier axisLabels
    __axisLabels = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'axisLabels'), 'axisLabels', '__httpwww_opengis_netgml3_2_DirectPositionListType_axisLabels', _module_typeBindings.NCNameList)
    __axisLabels._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic0d1d.xsd', 47, 2)
    __axisLabels._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic0d1d.xsd', 47, 2)
    
    axisLabels = property(__axisLabels.value, __axisLabels.set, None, None)

    
    # Attribute uomLabels uses Python identifier uomLabels
    __uomLabels = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'uomLabels'), 'uomLabels', '__httpwww_opengis_netgml3_2_DirectPositionListType_uomLabels', _module_typeBindings.NCNameList)
    __uomLabels._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic0d1d.xsd', 48, 2)
    __uomLabels._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic0d1d.xsd', 48, 2)
    
    uomLabels = property(__uomLabels.value, __uomLabels.set, None, None)

    
    # Attribute count uses Python identifier count
    __count = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'count'), 'count', '__httpwww_opengis_netgml3_2_DirectPositionListType_count', pyxb.binding.datatypes.positiveInteger)
    __count._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic0d1d.xsd', 98, 4)
    __count._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic0d1d.xsd', 98, 4)
    
    count = property(__count.value, __count.set, None, None)

    _ElementMap.update({
        
    })
    _AttributeMap.update({
        __srsName.name() : __srsName,
        __srsDimension.name() : __srsDimension,
        __axisLabels.name() : __axisLabels,
        __uomLabels.name() : __uomLabels,
        __count.name() : __count
    })
_module_typeBindings.DirectPositionListType = DirectPositionListType
_Namespace_gml.addCategoryObject('typeBinding', 'DirectPositionListType', DirectPositionListType)


# Complex type {http://www.opengis.net/gml/3.2}EnvelopeType with content type ELEMENT_ONLY
class EnvelopeType (pyxb.binding.basis.complexTypeDefinition):
    """Complex type {http://www.opengis.net/gml/3.2}EnvelopeType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'EnvelopeType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic0d1d.xsd', 133, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.opengis.net/gml/3.2}coordinates uses Python identifier coordinates
    __coordinates = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'coordinates'), 'coordinates', '__httpwww_opengis_netgml3_2_EnvelopeType_httpwww_opengis_netgml3_2coordinates', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 751, 1), )

    
    coordinates = property(__coordinates.value, __coordinates.set, None, '')

    
    # Element {http://www.opengis.net/gml/3.2}pos uses Python identifier pos
    __pos = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'pos'), 'pos', '__httpwww_opengis_netgml3_2_EnvelopeType_httpwww_opengis_netgml3_2pos', True, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic0d1d.xsd', 87, 1), )

    
    pos = property(__pos.value, __pos.set, None, None)

    
    # Element {http://www.opengis.net/gml/3.2}lowerCorner uses Python identifier lowerCorner
    __lowerCorner = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'lowerCorner'), 'lowerCorner', '__httpwww_opengis_netgml3_2_EnvelopeType_httpwww_opengis_netgml3_2lowerCorner', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic0d1d.xsd', 136, 4), )

    
    lowerCorner = property(__lowerCorner.value, __lowerCorner.set, None, None)

    
    # Element {http://www.opengis.net/gml/3.2}upperCorner uses Python identifier upperCorner
    __upperCorner = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'upperCorner'), 'upperCorner', '__httpwww_opengis_netgml3_2_EnvelopeType_httpwww_opengis_netgml3_2upperCorner', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic0d1d.xsd', 137, 4), )

    
    upperCorner = property(__upperCorner.value, __upperCorner.set, None, None)

    
    # Attribute srsName uses Python identifier srsName
    __srsName = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'srsName'), 'srsName', '__httpwww_opengis_netgml3_2_EnvelopeType_srsName', pyxb.binding.datatypes.anyURI)
    __srsName._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic0d1d.xsd', 37, 2)
    __srsName._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic0d1d.xsd', 37, 2)
    
    srsName = property(__srsName.value, __srsName.set, None, None)

    
    # Attribute srsDimension uses Python identifier srsDimension
    __srsDimension = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'srsDimension'), 'srsDimension', '__httpwww_opengis_netgml3_2_EnvelopeType_srsDimension', pyxb.binding.datatypes.positiveInteger)
    __srsDimension._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic0d1d.xsd', 38, 2)
    __srsDimension._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic0d1d.xsd', 38, 2)
    
    srsDimension = property(__srsDimension.value, __srsDimension.set, None, None)

    
    # Attribute axisLabels uses Python identifier axisLabels
    __axisLabels = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'axisLabels'), 'axisLabels', '__httpwww_opengis_netgml3_2_EnvelopeType_axisLabels', _module_typeBindings.NCNameList)
    __axisLabels._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic0d1d.xsd', 47, 2)
    __axisLabels._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic0d1d.xsd', 47, 2)
    
    axisLabels = property(__axisLabels.value, __axisLabels.set, None, None)

    
    # Attribute uomLabels uses Python identifier uomLabels
    __uomLabels = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'uomLabels'), 'uomLabels', '__httpwww_opengis_netgml3_2_EnvelopeType_uomLabels', _module_typeBindings.NCNameList)
    __uomLabels._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic0d1d.xsd', 48, 2)
    __uomLabels._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic0d1d.xsd', 48, 2)
    
    uomLabels = property(__uomLabels.value, __uomLabels.set, None, None)

    _ElementMap.update({
        __coordinates.name() : __coordinates,
        __pos.name() : __pos,
        __lowerCorner.name() : __lowerCorner,
        __upperCorner.name() : __upperCorner
    })
    _AttributeMap.update({
        __srsName.name() : __srsName,
        __srsDimension.name() : __srsDimension,
        __axisLabels.name() : __axisLabels,
        __uomLabels.name() : __uomLabels
    })
_module_typeBindings.EnvelopeType = EnvelopeType
_Namespace_gml.addCategoryObject('typeBinding', 'EnvelopeType', EnvelopeType)


# Complex type {http://www.opengis.net/gml/3.2}LineStringSegmentType with content type ELEMENT_ONLY
class LineStringSegmentType (AbstractCurveSegmentType):
    """Complex type {http://www.opengis.net/gml/3.2}LineStringSegmentType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'LineStringSegmentType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 96, 1)
    _ElementMap = AbstractCurveSegmentType._ElementMap.copy()
    _AttributeMap = AbstractCurveSegmentType._AttributeMap.copy()
    # Base type is AbstractCurveSegmentType
    
    # Element {http://www.opengis.net/gml/3.2}coordinates uses Python identifier coordinates
    __coordinates = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'coordinates'), 'coordinates', '__httpwww_opengis_netgml3_2_LineStringSegmentType_httpwww_opengis_netgml3_2coordinates', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 751, 1), )

    
    coordinates = property(__coordinates.value, __coordinates.set, None, '')

    
    # Element {http://www.opengis.net/gml/3.2}pointRep uses Python identifier pointRep
    __pointRep = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'pointRep'), 'pointRep', '__httpwww_opengis_netgml3_2_LineStringSegmentType_httpwww_opengis_netgml3_2pointRep', True, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 756, 1), )

    
    pointRep = property(__pointRep.value, __pointRep.set, None, '')

    
    # Element {http://www.opengis.net/gml/3.2}pos uses Python identifier pos
    __pos = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'pos'), 'pos', '__httpwww_opengis_netgml3_2_LineStringSegmentType_httpwww_opengis_netgml3_2pos', True, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic0d1d.xsd', 87, 1), )

    
    pos = property(__pos.value, __pos.set, None, None)

    
    # Element {http://www.opengis.net/gml/3.2}posList uses Python identifier posList
    __posList = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'posList'), 'posList', '__httpwww_opengis_netgml3_2_LineStringSegmentType_httpwww_opengis_netgml3_2posList', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic0d1d.xsd', 102, 1), )

    
    posList = property(__posList.value, __posList.set, None, None)

    
    # Element {http://www.opengis.net/gml/3.2}pointProperty uses Python identifier pointProperty
    __pointProperty = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'pointProperty'), 'pointProperty', '__httpwww_opengis_netgml3_2_LineStringSegmentType_httpwww_opengis_netgml3_2pointProperty', True, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic0d1d.xsd', 204, 1), )

    
    pointProperty = property(__pointProperty.value, __pointProperty.set, None, 'This property element either references a point via the XLink-attributes or contains the point element. pointProperty is the predefined property which may be used by GML Application Schemas whenever a GML feature has a property with a value that is substitutable for Point.')

    
    # Attribute numDerivativesAtStart inherited from {http://www.opengis.net/gml/3.2}AbstractCurveSegmentType
    
    # Attribute numDerivativesAtEnd inherited from {http://www.opengis.net/gml/3.2}AbstractCurveSegmentType
    
    # Attribute numDerivativeInterior inherited from {http://www.opengis.net/gml/3.2}AbstractCurveSegmentType
    
    # Attribute interpolation uses Python identifier interpolation
    __interpolation = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'interpolation'), 'interpolation', '__httpwww_opengis_netgml3_2_LineStringSegmentType_interpolation', _module_typeBindings.CurveInterpolationType, fixed=True, unicode_default='linear')
    __interpolation._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 110, 4)
    __interpolation._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 110, 4)
    
    interpolation = property(__interpolation.value, __interpolation.set, None, None)

    _ElementMap.update({
        __coordinates.name() : __coordinates,
        __pointRep.name() : __pointRep,
        __pos.name() : __pos,
        __posList.name() : __posList,
        __pointProperty.name() : __pointProperty
    })
    _AttributeMap.update({
        __interpolation.name() : __interpolation
    })
_module_typeBindings.LineStringSegmentType = LineStringSegmentType
_Namespace_gml.addCategoryObject('typeBinding', 'LineStringSegmentType', LineStringSegmentType)


# Complex type {http://www.opengis.net/gml/3.2}ArcStringType with content type ELEMENT_ONLY
class ArcStringType (AbstractCurveSegmentType):
    """Complex type {http://www.opengis.net/gml/3.2}ArcStringType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'ArcStringType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 120, 1)
    _ElementMap = AbstractCurveSegmentType._ElementMap.copy()
    _AttributeMap = AbstractCurveSegmentType._AttributeMap.copy()
    # Base type is AbstractCurveSegmentType
    
    # Element {http://www.opengis.net/gml/3.2}coordinates uses Python identifier coordinates
    __coordinates = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'coordinates'), 'coordinates', '__httpwww_opengis_netgml3_2_ArcStringType_httpwww_opengis_netgml3_2coordinates', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 751, 1), )

    
    coordinates = property(__coordinates.value, __coordinates.set, None, '')

    
    # Element {http://www.opengis.net/gml/3.2}pointRep uses Python identifier pointRep
    __pointRep = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'pointRep'), 'pointRep', '__httpwww_opengis_netgml3_2_ArcStringType_httpwww_opengis_netgml3_2pointRep', True, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 756, 1), )

    
    pointRep = property(__pointRep.value, __pointRep.set, None, '')

    
    # Element {http://www.opengis.net/gml/3.2}pos uses Python identifier pos
    __pos = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'pos'), 'pos', '__httpwww_opengis_netgml3_2_ArcStringType_httpwww_opengis_netgml3_2pos', True, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic0d1d.xsd', 87, 1), )

    
    pos = property(__pos.value, __pos.set, None, None)

    
    # Element {http://www.opengis.net/gml/3.2}posList uses Python identifier posList
    __posList = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'posList'), 'posList', '__httpwww_opengis_netgml3_2_ArcStringType_httpwww_opengis_netgml3_2posList', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic0d1d.xsd', 102, 1), )

    
    posList = property(__posList.value, __posList.set, None, None)

    
    # Element {http://www.opengis.net/gml/3.2}pointProperty uses Python identifier pointProperty
    __pointProperty = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'pointProperty'), 'pointProperty', '__httpwww_opengis_netgml3_2_ArcStringType_httpwww_opengis_netgml3_2pointProperty', True, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic0d1d.xsd', 204, 1), )

    
    pointProperty = property(__pointProperty.value, __pointProperty.set, None, 'This property element either references a point via the XLink-attributes or contains the point element. pointProperty is the predefined property which may be used by GML Application Schemas whenever a GML feature has a property with a value that is substitutable for Point.')

    
    # Attribute numDerivativesAtStart inherited from {http://www.opengis.net/gml/3.2}AbstractCurveSegmentType
    
    # Attribute numDerivativesAtEnd inherited from {http://www.opengis.net/gml/3.2}AbstractCurveSegmentType
    
    # Attribute numDerivativeInterior inherited from {http://www.opengis.net/gml/3.2}AbstractCurveSegmentType
    
    # Attribute interpolation uses Python identifier interpolation
    __interpolation = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'interpolation'), 'interpolation', '__httpwww_opengis_netgml3_2_ArcStringType_interpolation', _module_typeBindings.CurveInterpolationType, fixed=True, unicode_default='circularArc3Points')
    __interpolation._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 134, 4)
    __interpolation._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 134, 4)
    
    interpolation = property(__interpolation.value, __interpolation.set, None, None)

    
    # Attribute numArc uses Python identifier numArc
    __numArc = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'numArc'), 'numArc', '__httpwww_opengis_netgml3_2_ArcStringType_numArc', pyxb.binding.datatypes.integer)
    __numArc._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 135, 4)
    __numArc._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 135, 4)
    
    numArc = property(__numArc.value, __numArc.set, None, None)

    _ElementMap.update({
        __coordinates.name() : __coordinates,
        __pointRep.name() : __pointRep,
        __pos.name() : __pos,
        __posList.name() : __posList,
        __pointProperty.name() : __pointProperty
    })
    _AttributeMap.update({
        __interpolation.name() : __interpolation,
        __numArc.name() : __numArc
    })
_module_typeBindings.ArcStringType = ArcStringType
_Namespace_gml.addCategoryObject('typeBinding', 'ArcStringType', ArcStringType)


# Complex type {http://www.opengis.net/gml/3.2}ArcStringByBulgeType with content type ELEMENT_ONLY
class ArcStringByBulgeType (AbstractCurveSegmentType):
    """Complex type {http://www.opengis.net/gml/3.2}ArcStringByBulgeType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'ArcStringByBulgeType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 178, 1)
    _ElementMap = AbstractCurveSegmentType._ElementMap.copy()
    _AttributeMap = AbstractCurveSegmentType._AttributeMap.copy()
    # Base type is AbstractCurveSegmentType
    
    # Element {http://www.opengis.net/gml/3.2}coordinates uses Python identifier coordinates
    __coordinates = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'coordinates'), 'coordinates', '__httpwww_opengis_netgml3_2_ArcStringByBulgeType_httpwww_opengis_netgml3_2coordinates', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 751, 1), )

    
    coordinates = property(__coordinates.value, __coordinates.set, None, '')

    
    # Element {http://www.opengis.net/gml/3.2}pointRep uses Python identifier pointRep
    __pointRep = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'pointRep'), 'pointRep', '__httpwww_opengis_netgml3_2_ArcStringByBulgeType_httpwww_opengis_netgml3_2pointRep', True, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 756, 1), )

    
    pointRep = property(__pointRep.value, __pointRep.set, None, '')

    
    # Element {http://www.opengis.net/gml/3.2}pos uses Python identifier pos
    __pos = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'pos'), 'pos', '__httpwww_opengis_netgml3_2_ArcStringByBulgeType_httpwww_opengis_netgml3_2pos', True, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic0d1d.xsd', 87, 1), )

    
    pos = property(__pos.value, __pos.set, None, None)

    
    # Element {http://www.opengis.net/gml/3.2}posList uses Python identifier posList
    __posList = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'posList'), 'posList', '__httpwww_opengis_netgml3_2_ArcStringByBulgeType_httpwww_opengis_netgml3_2posList', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic0d1d.xsd', 102, 1), )

    
    posList = property(__posList.value, __posList.set, None, None)

    
    # Element {http://www.opengis.net/gml/3.2}pointProperty uses Python identifier pointProperty
    __pointProperty = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'pointProperty'), 'pointProperty', '__httpwww_opengis_netgml3_2_ArcStringByBulgeType_httpwww_opengis_netgml3_2pointProperty', True, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic0d1d.xsd', 204, 1), )

    
    pointProperty = property(__pointProperty.value, __pointProperty.set, None, 'This property element either references a point via the XLink-attributes or contains the point element. pointProperty is the predefined property which may be used by GML Application Schemas whenever a GML feature has a property with a value that is substitutable for Point.')

    
    # Element {http://www.opengis.net/gml/3.2}bulge uses Python identifier bulge
    __bulge = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'bulge'), 'bulge', '__httpwww_opengis_netgml3_2_ArcStringByBulgeType_httpwww_opengis_netgml3_2bulge', True, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 191, 5), )

    
    bulge = property(__bulge.value, __bulge.set, None, None)

    
    # Element {http://www.opengis.net/gml/3.2}normal uses Python identifier normal
    __normal = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'normal'), 'normal', '__httpwww_opengis_netgml3_2_ArcStringByBulgeType_httpwww_opengis_netgml3_2normal', True, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 192, 5), )

    
    normal = property(__normal.value, __normal.set, None, None)

    
    # Attribute numDerivativesAtStart inherited from {http://www.opengis.net/gml/3.2}AbstractCurveSegmentType
    
    # Attribute numDerivativesAtEnd inherited from {http://www.opengis.net/gml/3.2}AbstractCurveSegmentType
    
    # Attribute numDerivativeInterior inherited from {http://www.opengis.net/gml/3.2}AbstractCurveSegmentType
    
    # Attribute interpolation uses Python identifier interpolation
    __interpolation = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'interpolation'), 'interpolation', '__httpwww_opengis_netgml3_2_ArcStringByBulgeType_interpolation', _module_typeBindings.CurveInterpolationType, fixed=True, unicode_default='circularArc2PointWithBulge')
    __interpolation._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 194, 4)
    __interpolation._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 194, 4)
    
    interpolation = property(__interpolation.value, __interpolation.set, None, None)

    
    # Attribute numArc uses Python identifier numArc
    __numArc = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'numArc'), 'numArc', '__httpwww_opengis_netgml3_2_ArcStringByBulgeType_numArc', pyxb.binding.datatypes.integer)
    __numArc._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 195, 4)
    __numArc._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 195, 4)
    
    numArc = property(__numArc.value, __numArc.set, None, None)

    _ElementMap.update({
        __coordinates.name() : __coordinates,
        __pointRep.name() : __pointRep,
        __pos.name() : __pos,
        __posList.name() : __posList,
        __pointProperty.name() : __pointProperty,
        __bulge.name() : __bulge,
        __normal.name() : __normal
    })
    _AttributeMap.update({
        __interpolation.name() : __interpolation,
        __numArc.name() : __numArc
    })
_module_typeBindings.ArcStringByBulgeType = ArcStringByBulgeType
_Namespace_gml.addCategoryObject('typeBinding', 'ArcStringByBulgeType', ArcStringByBulgeType)


# Complex type {http://www.opengis.net/gml/3.2}ArcByCenterPointType with content type ELEMENT_ONLY
class ArcByCenterPointType (AbstractCurveSegmentType):
    """Complex type {http://www.opengis.net/gml/3.2}ArcByCenterPointType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'ArcByCenterPointType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 233, 1)
    _ElementMap = AbstractCurveSegmentType._ElementMap.copy()
    _AttributeMap = AbstractCurveSegmentType._AttributeMap.copy()
    # Base type is AbstractCurveSegmentType
    
    # Element {http://www.opengis.net/gml/3.2}coordinates uses Python identifier coordinates
    __coordinates = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'coordinates'), 'coordinates', '__httpwww_opengis_netgml3_2_ArcByCenterPointType_httpwww_opengis_netgml3_2coordinates', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 751, 1), )

    
    coordinates = property(__coordinates.value, __coordinates.set, None, '')

    
    # Element {http://www.opengis.net/gml/3.2}pointRep uses Python identifier pointRep
    __pointRep = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'pointRep'), 'pointRep', '__httpwww_opengis_netgml3_2_ArcByCenterPointType_httpwww_opengis_netgml3_2pointRep', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 756, 1), )

    
    pointRep = property(__pointRep.value, __pointRep.set, None, '')

    
    # Element {http://www.opengis.net/gml/3.2}pos uses Python identifier pos
    __pos = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'pos'), 'pos', '__httpwww_opengis_netgml3_2_ArcByCenterPointType_httpwww_opengis_netgml3_2pos', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic0d1d.xsd', 87, 1), )

    
    pos = property(__pos.value, __pos.set, None, None)

    
    # Element {http://www.opengis.net/gml/3.2}posList uses Python identifier posList
    __posList = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'posList'), 'posList', '__httpwww_opengis_netgml3_2_ArcByCenterPointType_httpwww_opengis_netgml3_2posList', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic0d1d.xsd', 102, 1), )

    
    posList = property(__posList.value, __posList.set, None, None)

    
    # Element {http://www.opengis.net/gml/3.2}pointProperty uses Python identifier pointProperty
    __pointProperty = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'pointProperty'), 'pointProperty', '__httpwww_opengis_netgml3_2_ArcByCenterPointType_httpwww_opengis_netgml3_2pointProperty', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic0d1d.xsd', 204, 1), )

    
    pointProperty = property(__pointProperty.value, __pointProperty.set, None, 'This property element either references a point via the XLink-attributes or contains the point element. pointProperty is the predefined property which may be used by GML Application Schemas whenever a GML feature has a property with a value that is substitutable for Point.')

    
    # Element {http://www.opengis.net/gml/3.2}radius uses Python identifier radius
    __radius = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'radius'), 'radius', '__httpwww_opengis_netgml3_2_ArcByCenterPointType_httpwww_opengis_netgml3_2radius', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 246, 5), )

    
    radius = property(__radius.value, __radius.set, None, None)

    
    # Element {http://www.opengis.net/gml/3.2}startAngle uses Python identifier startAngle
    __startAngle = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'startAngle'), 'startAngle', '__httpwww_opengis_netgml3_2_ArcByCenterPointType_httpwww_opengis_netgml3_2startAngle', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 247, 5), )

    
    startAngle = property(__startAngle.value, __startAngle.set, None, None)

    
    # Element {http://www.opengis.net/gml/3.2}endAngle uses Python identifier endAngle
    __endAngle = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'endAngle'), 'endAngle', '__httpwww_opengis_netgml3_2_ArcByCenterPointType_httpwww_opengis_netgml3_2endAngle', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 248, 5), )

    
    endAngle = property(__endAngle.value, __endAngle.set, None, None)

    
    # Attribute numDerivativesAtStart inherited from {http://www.opengis.net/gml/3.2}AbstractCurveSegmentType
    
    # Attribute numDerivativesAtEnd inherited from {http://www.opengis.net/gml/3.2}AbstractCurveSegmentType
    
    # Attribute numDerivativeInterior inherited from {http://www.opengis.net/gml/3.2}AbstractCurveSegmentType
    
    # Attribute interpolation uses Python identifier interpolation
    __interpolation = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'interpolation'), 'interpolation', '__httpwww_opengis_netgml3_2_ArcByCenterPointType_interpolation', _module_typeBindings.CurveInterpolationType, fixed=True, unicode_default='circularArcCenterPointWithRadius')
    __interpolation._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 250, 4)
    __interpolation._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 250, 4)
    
    interpolation = property(__interpolation.value, __interpolation.set, None, None)

    
    # Attribute numArc uses Python identifier numArc
    __numArc = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'numArc'), 'numArc', '__httpwww_opengis_netgml3_2_ArcByCenterPointType_numArc', pyxb.binding.datatypes.integer, fixed=True, unicode_default='1', required=True)
    __numArc._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 251, 4)
    __numArc._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 251, 4)
    
    numArc = property(__numArc.value, __numArc.set, None, None)

    _ElementMap.update({
        __coordinates.name() : __coordinates,
        __pointRep.name() : __pointRep,
        __pos.name() : __pos,
        __posList.name() : __posList,
        __pointProperty.name() : __pointProperty,
        __radius.name() : __radius,
        __startAngle.name() : __startAngle,
        __endAngle.name() : __endAngle
    })
    _AttributeMap.update({
        __interpolation.name() : __interpolation,
        __numArc.name() : __numArc
    })
_module_typeBindings.ArcByCenterPointType = ArcByCenterPointType
_Namespace_gml.addCategoryObject('typeBinding', 'ArcByCenterPointType', ArcByCenterPointType)


# Complex type {http://www.opengis.net/gml/3.2}CubicSplineType with content type ELEMENT_ONLY
class CubicSplineType (AbstractCurveSegmentType):
    """Complex type {http://www.opengis.net/gml/3.2}CubicSplineType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'CubicSplineType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 289, 1)
    _ElementMap = AbstractCurveSegmentType._ElementMap.copy()
    _AttributeMap = AbstractCurveSegmentType._AttributeMap.copy()
    # Base type is AbstractCurveSegmentType
    
    # Element {http://www.opengis.net/gml/3.2}coordinates uses Python identifier coordinates
    __coordinates = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'coordinates'), 'coordinates', '__httpwww_opengis_netgml3_2_CubicSplineType_httpwww_opengis_netgml3_2coordinates', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 751, 1), )

    
    coordinates = property(__coordinates.value, __coordinates.set, None, '')

    
    # Element {http://www.opengis.net/gml/3.2}pointRep uses Python identifier pointRep
    __pointRep = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'pointRep'), 'pointRep', '__httpwww_opengis_netgml3_2_CubicSplineType_httpwww_opengis_netgml3_2pointRep', True, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 756, 1), )

    
    pointRep = property(__pointRep.value, __pointRep.set, None, '')

    
    # Element {http://www.opengis.net/gml/3.2}pos uses Python identifier pos
    __pos = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'pos'), 'pos', '__httpwww_opengis_netgml3_2_CubicSplineType_httpwww_opengis_netgml3_2pos', True, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic0d1d.xsd', 87, 1), )

    
    pos = property(__pos.value, __pos.set, None, None)

    
    # Element {http://www.opengis.net/gml/3.2}posList uses Python identifier posList
    __posList = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'posList'), 'posList', '__httpwww_opengis_netgml3_2_CubicSplineType_httpwww_opengis_netgml3_2posList', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic0d1d.xsd', 102, 1), )

    
    posList = property(__posList.value, __posList.set, None, None)

    
    # Element {http://www.opengis.net/gml/3.2}pointProperty uses Python identifier pointProperty
    __pointProperty = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'pointProperty'), 'pointProperty', '__httpwww_opengis_netgml3_2_CubicSplineType_httpwww_opengis_netgml3_2pointProperty', True, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic0d1d.xsd', 204, 1), )

    
    pointProperty = property(__pointProperty.value, __pointProperty.set, None, 'This property element either references a point via the XLink-attributes or contains the point element. pointProperty is the predefined property which may be used by GML Application Schemas whenever a GML feature has a property with a value that is substitutable for Point.')

    
    # Element {http://www.opengis.net/gml/3.2}vectorAtStart uses Python identifier vectorAtStart
    __vectorAtStart = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'vectorAtStart'), 'vectorAtStart', '__httpwww_opengis_netgml3_2_CubicSplineType_httpwww_opengis_netgml3_2vectorAtStart', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 302, 5), )

    
    vectorAtStart = property(__vectorAtStart.value, __vectorAtStart.set, None, None)

    
    # Element {http://www.opengis.net/gml/3.2}vectorAtEnd uses Python identifier vectorAtEnd
    __vectorAtEnd = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'vectorAtEnd'), 'vectorAtEnd', '__httpwww_opengis_netgml3_2_CubicSplineType_httpwww_opengis_netgml3_2vectorAtEnd', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 303, 5), )

    
    vectorAtEnd = property(__vectorAtEnd.value, __vectorAtEnd.set, None, None)

    
    # Attribute numDerivativesAtStart inherited from {http://www.opengis.net/gml/3.2}AbstractCurveSegmentType
    
    # Attribute numDerivativesAtEnd inherited from {http://www.opengis.net/gml/3.2}AbstractCurveSegmentType
    
    # Attribute numDerivativeInterior inherited from {http://www.opengis.net/gml/3.2}AbstractCurveSegmentType
    
    # Attribute interpolation uses Python identifier interpolation
    __interpolation = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'interpolation'), 'interpolation', '__httpwww_opengis_netgml3_2_CubicSplineType_interpolation', _module_typeBindings.CurveInterpolationType, fixed=True, unicode_default='cubicSpline')
    __interpolation._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 305, 4)
    __interpolation._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 305, 4)
    
    interpolation = property(__interpolation.value, __interpolation.set, None, None)

    
    # Attribute degree uses Python identifier degree
    __degree = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'degree'), 'degree', '__httpwww_opengis_netgml3_2_CubicSplineType_degree', pyxb.binding.datatypes.integer, fixed=True, unicode_default='3')
    __degree._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 306, 4)
    __degree._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 306, 4)
    
    degree = property(__degree.value, __degree.set, None, None)

    _ElementMap.update({
        __coordinates.name() : __coordinates,
        __pointRep.name() : __pointRep,
        __pos.name() : __pos,
        __posList.name() : __posList,
        __pointProperty.name() : __pointProperty,
        __vectorAtStart.name() : __vectorAtStart,
        __vectorAtEnd.name() : __vectorAtEnd
    })
    _AttributeMap.update({
        __interpolation.name() : __interpolation,
        __degree.name() : __degree
    })
_module_typeBindings.CubicSplineType = CubicSplineType
_Namespace_gml.addCategoryObject('typeBinding', 'CubicSplineType', CubicSplineType)


# Complex type {http://www.opengis.net/gml/3.2}BSplineType with content type ELEMENT_ONLY
class BSplineType (AbstractCurveSegmentType):
    """Complex type {http://www.opengis.net/gml/3.2}BSplineType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'BSplineType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 319, 1)
    _ElementMap = AbstractCurveSegmentType._ElementMap.copy()
    _AttributeMap = AbstractCurveSegmentType._AttributeMap.copy()
    # Base type is AbstractCurveSegmentType
    
    # Element {http://www.opengis.net/gml/3.2}coordinates uses Python identifier coordinates
    __coordinates = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'coordinates'), 'coordinates', '__httpwww_opengis_netgml3_2_BSplineType_httpwww_opengis_netgml3_2coordinates', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 751, 1), )

    
    coordinates = property(__coordinates.value, __coordinates.set, None, '')

    
    # Element {http://www.opengis.net/gml/3.2}pointRep uses Python identifier pointRep
    __pointRep = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'pointRep'), 'pointRep', '__httpwww_opengis_netgml3_2_BSplineType_httpwww_opengis_netgml3_2pointRep', True, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 756, 1), )

    
    pointRep = property(__pointRep.value, __pointRep.set, None, '')

    
    # Element {http://www.opengis.net/gml/3.2}pos uses Python identifier pos
    __pos = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'pos'), 'pos', '__httpwww_opengis_netgml3_2_BSplineType_httpwww_opengis_netgml3_2pos', True, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic0d1d.xsd', 87, 1), )

    
    pos = property(__pos.value, __pos.set, None, None)

    
    # Element {http://www.opengis.net/gml/3.2}posList uses Python identifier posList
    __posList = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'posList'), 'posList', '__httpwww_opengis_netgml3_2_BSplineType_httpwww_opengis_netgml3_2posList', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic0d1d.xsd', 102, 1), )

    
    posList = property(__posList.value, __posList.set, None, None)

    
    # Element {http://www.opengis.net/gml/3.2}pointProperty uses Python identifier pointProperty
    __pointProperty = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'pointProperty'), 'pointProperty', '__httpwww_opengis_netgml3_2_BSplineType_httpwww_opengis_netgml3_2pointProperty', True, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic0d1d.xsd', 204, 1), )

    
    pointProperty = property(__pointProperty.value, __pointProperty.set, None, 'This property element either references a point via the XLink-attributes or contains the point element. pointProperty is the predefined property which may be used by GML Application Schemas whenever a GML feature has a property with a value that is substitutable for Point.')

    
    # Element {http://www.opengis.net/gml/3.2}degree uses Python identifier degree
    __degree = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'degree'), 'degree', '__httpwww_opengis_netgml3_2_BSplineType_httpwww_opengis_netgml3_2degree', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 332, 5), )

    
    degree = property(__degree.value, __degree.set, None, None)

    
    # Element {http://www.opengis.net/gml/3.2}knot uses Python identifier knot
    __knot = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'knot'), 'knot', '__httpwww_opengis_netgml3_2_BSplineType_httpwww_opengis_netgml3_2knot', True, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 333, 5), )

    
    knot = property(__knot.value, __knot.set, None, None)

    
    # Attribute numDerivativesAtStart inherited from {http://www.opengis.net/gml/3.2}AbstractCurveSegmentType
    
    # Attribute numDerivativesAtEnd inherited from {http://www.opengis.net/gml/3.2}AbstractCurveSegmentType
    
    # Attribute numDerivativeInterior inherited from {http://www.opengis.net/gml/3.2}AbstractCurveSegmentType
    
    # Attribute interpolation uses Python identifier interpolation
    __interpolation = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'interpolation'), 'interpolation', '__httpwww_opengis_netgml3_2_BSplineType_interpolation', _module_typeBindings.CurveInterpolationType, unicode_default='polynomialSpline')
    __interpolation._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 335, 4)
    __interpolation._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 335, 4)
    
    interpolation = property(__interpolation.value, __interpolation.set, None, None)

    
    # Attribute isPolynomial uses Python identifier isPolynomial
    __isPolynomial = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'isPolynomial'), 'isPolynomial', '__httpwww_opengis_netgml3_2_BSplineType_isPolynomial', pyxb.binding.datatypes.boolean)
    __isPolynomial._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 336, 4)
    __isPolynomial._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 336, 4)
    
    isPolynomial = property(__isPolynomial.value, __isPolynomial.set, None, None)

    
    # Attribute knotType uses Python identifier knotType
    __knotType = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'knotType'), 'knotType', '__httpwww_opengis_netgml3_2_BSplineType_knotType', _module_typeBindings.KnotTypesType)
    __knotType._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 337, 4)
    __knotType._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 337, 4)
    
    knotType = property(__knotType.value, __knotType.set, None, None)

    _ElementMap.update({
        __coordinates.name() : __coordinates,
        __pointRep.name() : __pointRep,
        __pos.name() : __pos,
        __posList.name() : __posList,
        __pointProperty.name() : __pointProperty,
        __degree.name() : __degree,
        __knot.name() : __knot
    })
    _AttributeMap.update({
        __interpolation.name() : __interpolation,
        __isPolynomial.name() : __isPolynomial,
        __knotType.name() : __knotType
    })
_module_typeBindings.BSplineType = BSplineType
_Namespace_gml.addCategoryObject('typeBinding', 'BSplineType', BSplineType)


# Complex type {http://www.opengis.net/gml/3.2}OffsetCurveType with content type ELEMENT_ONLY
class OffsetCurveType (AbstractCurveSegmentType):
    """Complex type {http://www.opengis.net/gml/3.2}OffsetCurveType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'OffsetCurveType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 416, 1)
    _ElementMap = AbstractCurveSegmentType._ElementMap.copy()
    _AttributeMap = AbstractCurveSegmentType._AttributeMap.copy()
    # Base type is AbstractCurveSegmentType
    
    # Element {http://www.opengis.net/gml/3.2}offsetBase uses Python identifier offsetBase
    __offsetBase = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'offsetBase'), 'offsetBase', '__httpwww_opengis_netgml3_2_OffsetCurveType_httpwww_opengis_netgml3_2offsetBase', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 420, 5), )

    
    offsetBase = property(__offsetBase.value, __offsetBase.set, None, None)

    
    # Element {http://www.opengis.net/gml/3.2}distance uses Python identifier distance
    __distance = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'distance'), 'distance', '__httpwww_opengis_netgml3_2_OffsetCurveType_httpwww_opengis_netgml3_2distance', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 421, 5), )

    
    distance = property(__distance.value, __distance.set, None, None)

    
    # Element {http://www.opengis.net/gml/3.2}refDirection uses Python identifier refDirection
    __refDirection = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'refDirection'), 'refDirection', '__httpwww_opengis_netgml3_2_OffsetCurveType_httpwww_opengis_netgml3_2refDirection', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 422, 5), )

    
    refDirection = property(__refDirection.value, __refDirection.set, None, None)

    
    # Attribute numDerivativesAtStart inherited from {http://www.opengis.net/gml/3.2}AbstractCurveSegmentType
    
    # Attribute numDerivativesAtEnd inherited from {http://www.opengis.net/gml/3.2}AbstractCurveSegmentType
    
    # Attribute numDerivativeInterior inherited from {http://www.opengis.net/gml/3.2}AbstractCurveSegmentType
    _ElementMap.update({
        __offsetBase.name() : __offsetBase,
        __distance.name() : __distance,
        __refDirection.name() : __refDirection
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.OffsetCurveType = OffsetCurveType
_Namespace_gml.addCategoryObject('typeBinding', 'OffsetCurveType', OffsetCurveType)


# Complex type {http://www.opengis.net/gml/3.2}ClothoidType with content type ELEMENT_ONLY
class ClothoidType (AbstractCurveSegmentType):
    """Complex type {http://www.opengis.net/gml/3.2}ClothoidType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'ClothoidType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 446, 1)
    _ElementMap = AbstractCurveSegmentType._ElementMap.copy()
    _AttributeMap = AbstractCurveSegmentType._AttributeMap.copy()
    # Base type is AbstractCurveSegmentType
    
    # Element {http://www.opengis.net/gml/3.2}refLocation uses Python identifier refLocation
    __refLocation = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'refLocation'), 'refLocation', '__httpwww_opengis_netgml3_2_ClothoidType_httpwww_opengis_netgml3_2refLocation', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 450, 5), )

    
    refLocation = property(__refLocation.value, __refLocation.set, None, None)

    
    # Element {http://www.opengis.net/gml/3.2}scaleFactor uses Python identifier scaleFactor
    __scaleFactor = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'scaleFactor'), 'scaleFactor', '__httpwww_opengis_netgml3_2_ClothoidType_httpwww_opengis_netgml3_2scaleFactor', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 457, 5), )

    
    scaleFactor = property(__scaleFactor.value, __scaleFactor.set, None, None)

    
    # Element {http://www.opengis.net/gml/3.2}startParameter uses Python identifier startParameter
    __startParameter = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'startParameter'), 'startParameter', '__httpwww_opengis_netgml3_2_ClothoidType_httpwww_opengis_netgml3_2startParameter', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 458, 5), )

    
    startParameter = property(__startParameter.value, __startParameter.set, None, None)

    
    # Element {http://www.opengis.net/gml/3.2}endParameter uses Python identifier endParameter
    __endParameter = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'endParameter'), 'endParameter', '__httpwww_opengis_netgml3_2_ClothoidType_httpwww_opengis_netgml3_2endParameter', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 459, 5), )

    
    endParameter = property(__endParameter.value, __endParameter.set, None, None)

    
    # Attribute numDerivativesAtStart inherited from {http://www.opengis.net/gml/3.2}AbstractCurveSegmentType
    
    # Attribute numDerivativesAtEnd inherited from {http://www.opengis.net/gml/3.2}AbstractCurveSegmentType
    
    # Attribute numDerivativeInterior inherited from {http://www.opengis.net/gml/3.2}AbstractCurveSegmentType
    
    # Attribute interpolation uses Python identifier interpolation
    __interpolation = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'interpolation'), 'interpolation', '__httpwww_opengis_netgml3_2_ClothoidType_interpolation', _module_typeBindings.CurveInterpolationType, fixed=True, unicode_default='clothoid')
    __interpolation._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 461, 4)
    __interpolation._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 461, 4)
    
    interpolation = property(__interpolation.value, __interpolation.set, None, None)

    _ElementMap.update({
        __refLocation.name() : __refLocation,
        __scaleFactor.name() : __scaleFactor,
        __startParameter.name() : __startParameter,
        __endParameter.name() : __endParameter
    })
    _AttributeMap.update({
        __interpolation.name() : __interpolation
    })
_module_typeBindings.ClothoidType = ClothoidType
_Namespace_gml.addCategoryObject('typeBinding', 'ClothoidType', ClothoidType)


# Complex type {http://www.opengis.net/gml/3.2}GeodesicStringType with content type ELEMENT_ONLY
class GeodesicStringType (AbstractCurveSegmentType):
    """Complex type {http://www.opengis.net/gml/3.2}GeodesicStringType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'GeodesicStringType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 473, 1)
    _ElementMap = AbstractCurveSegmentType._ElementMap.copy()
    _AttributeMap = AbstractCurveSegmentType._AttributeMap.copy()
    # Base type is AbstractCurveSegmentType
    
    # Element {http://www.opengis.net/gml/3.2}pos uses Python identifier pos
    __pos = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'pos'), 'pos', '__httpwww_opengis_netgml3_2_GeodesicStringType_httpwww_opengis_netgml3_2pos', True, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic0d1d.xsd', 87, 1), )

    
    pos = property(__pos.value, __pos.set, None, None)

    
    # Element {http://www.opengis.net/gml/3.2}posList uses Python identifier posList
    __posList = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'posList'), 'posList', '__httpwww_opengis_netgml3_2_GeodesicStringType_httpwww_opengis_netgml3_2posList', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic0d1d.xsd', 102, 1), )

    
    posList = property(__posList.value, __posList.set, None, None)

    
    # Element {http://www.opengis.net/gml/3.2}pointProperty uses Python identifier pointProperty
    __pointProperty = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'pointProperty'), 'pointProperty', '__httpwww_opengis_netgml3_2_GeodesicStringType_httpwww_opengis_netgml3_2pointProperty', True, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic0d1d.xsd', 204, 1), )

    
    pointProperty = property(__pointProperty.value, __pointProperty.set, None, 'This property element either references a point via the XLink-attributes or contains the point element. pointProperty is the predefined property which may be used by GML Application Schemas whenever a GML feature has a property with a value that is substitutable for Point.')

    
    # Attribute numDerivativesAtStart inherited from {http://www.opengis.net/gml/3.2}AbstractCurveSegmentType
    
    # Attribute numDerivativesAtEnd inherited from {http://www.opengis.net/gml/3.2}AbstractCurveSegmentType
    
    # Attribute numDerivativeInterior inherited from {http://www.opengis.net/gml/3.2}AbstractCurveSegmentType
    
    # Attribute interpolation uses Python identifier interpolation
    __interpolation = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'interpolation'), 'interpolation', '__httpwww_opengis_netgml3_2_GeodesicStringType_interpolation', _module_typeBindings.CurveInterpolationType, fixed=True, unicode_default='geodesic')
    __interpolation._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 480, 4)
    __interpolation._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 480, 4)
    
    interpolation = property(__interpolation.value, __interpolation.set, None, None)

    _ElementMap.update({
        __pos.name() : __pos,
        __posList.name() : __posList,
        __pointProperty.name() : __pointProperty
    })
    _AttributeMap.update({
        __interpolation.name() : __interpolation
    })
_module_typeBindings.GeodesicStringType = GeodesicStringType
_Namespace_gml.addCategoryObject('typeBinding', 'GeodesicStringType', GeodesicStringType)


# Complex type {http://www.opengis.net/gml/3.2}PolygonPatchType with content type ELEMENT_ONLY
class PolygonPatchType (AbstractSurfacePatchType):
    """Complex type {http://www.opengis.net/gml/3.2}PolygonPatchType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'PolygonPatchType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 571, 1)
    _ElementMap = AbstractSurfacePatchType._ElementMap.copy()
    _AttributeMap = AbstractSurfacePatchType._AttributeMap.copy()
    # Base type is AbstractSurfacePatchType
    
    # Element {http://www.opengis.net/gml/3.2}exterior uses Python identifier exterior
    __exterior = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'exterior'), 'exterior', '__httpwww_opengis_netgml3_2_PolygonPatchType_httpwww_opengis_netgml3_2exterior', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic2d.xsd', 67, 1), )

    
    exterior = property(__exterior.value, __exterior.set, None, 'A boundary of a surface consists of a number of rings. In the normal 2D case, one of these rings is distinguished as being the exterior boundary. In a general manifold this is not always possible, in which case all boundaries shall be listed as interior boundaries, and the exterior will be empty.')

    
    # Element {http://www.opengis.net/gml/3.2}interior uses Python identifier interior
    __interior = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'interior'), 'interior', '__httpwww_opengis_netgml3_2_PolygonPatchType_httpwww_opengis_netgml3_2interior', True, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic2d.xsd', 72, 1), )

    
    interior = property(__interior.value, __interior.set, None, 'A boundary of a surface consists of a number of rings. The "interior" rings separate the surface / surface patch from the area enclosed by the rings.')

    
    # Attribute interpolation uses Python identifier interpolation
    __interpolation = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'interpolation'), 'interpolation', '__httpwww_opengis_netgml3_2_PolygonPatchType_interpolation', _module_typeBindings.SurfaceInterpolationType, fixed=True, unicode_default='planar')
    __interpolation._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 578, 4)
    __interpolation._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 578, 4)
    
    interpolation = property(__interpolation.value, __interpolation.set, None, None)

    _ElementMap.update({
        __exterior.name() : __exterior,
        __interior.name() : __interior
    })
    _AttributeMap.update({
        __interpolation.name() : __interpolation
    })
_module_typeBindings.PolygonPatchType = PolygonPatchType
_Namespace_gml.addCategoryObject('typeBinding', 'PolygonPatchType', PolygonPatchType)


# Complex type {http://www.opengis.net/gml/3.2}TriangleType with content type ELEMENT_ONLY
class TriangleType (AbstractSurfacePatchType):
    """Complex type {http://www.opengis.net/gml/3.2}TriangleType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'TriangleType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 588, 1)
    _ElementMap = AbstractSurfacePatchType._ElementMap.copy()
    _AttributeMap = AbstractSurfacePatchType._AttributeMap.copy()
    # Base type is AbstractSurfacePatchType
    
    # Element {http://www.opengis.net/gml/3.2}exterior uses Python identifier exterior
    __exterior = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'exterior'), 'exterior', '__httpwww_opengis_netgml3_2_TriangleType_httpwww_opengis_netgml3_2exterior', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic2d.xsd', 67, 1), )

    
    exterior = property(__exterior.value, __exterior.set, None, 'A boundary of a surface consists of a number of rings. In the normal 2D case, one of these rings is distinguished as being the exterior boundary. In a general manifold this is not always possible, in which case all boundaries shall be listed as interior boundaries, and the exterior will be empty.')

    
    # Attribute interpolation uses Python identifier interpolation
    __interpolation = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'interpolation'), 'interpolation', '__httpwww_opengis_netgml3_2_TriangleType_interpolation', _module_typeBindings.SurfaceInterpolationType, fixed=True, unicode_default='planar')
    __interpolation._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 594, 4)
    __interpolation._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 594, 4)
    
    interpolation = property(__interpolation.value, __interpolation.set, None, None)

    _ElementMap.update({
        __exterior.name() : __exterior
    })
    _AttributeMap.update({
        __interpolation.name() : __interpolation
    })
_module_typeBindings.TriangleType = TriangleType
_Namespace_gml.addCategoryObject('typeBinding', 'TriangleType', TriangleType)


# Complex type {http://www.opengis.net/gml/3.2}RectangleType with content type ELEMENT_ONLY
class RectangleType (AbstractSurfacePatchType):
    """Complex type {http://www.opengis.net/gml/3.2}RectangleType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'RectangleType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 605, 1)
    _ElementMap = AbstractSurfacePatchType._ElementMap.copy()
    _AttributeMap = AbstractSurfacePatchType._AttributeMap.copy()
    # Base type is AbstractSurfacePatchType
    
    # Element {http://www.opengis.net/gml/3.2}exterior uses Python identifier exterior
    __exterior = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'exterior'), 'exterior', '__httpwww_opengis_netgml3_2_RectangleType_httpwww_opengis_netgml3_2exterior', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic2d.xsd', 67, 1), )

    
    exterior = property(__exterior.value, __exterior.set, None, 'A boundary of a surface consists of a number of rings. In the normal 2D case, one of these rings is distinguished as being the exterior boundary. In a general manifold this is not always possible, in which case all boundaries shall be listed as interior boundaries, and the exterior will be empty.')

    
    # Attribute interpolation uses Python identifier interpolation
    __interpolation = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'interpolation'), 'interpolation', '__httpwww_opengis_netgml3_2_RectangleType_interpolation', _module_typeBindings.SurfaceInterpolationType, fixed=True, unicode_default='planar')
    __interpolation._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 611, 4)
    __interpolation._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 611, 4)
    
    interpolation = property(__interpolation.value, __interpolation.set, None, None)

    _ElementMap.update({
        __exterior.name() : __exterior
    })
    _AttributeMap.update({
        __interpolation.name() : __interpolation
    })
_module_typeBindings.RectangleType = RectangleType
_Namespace_gml.addCategoryObject('typeBinding', 'RectangleType', RectangleType)


# Complex type {http://www.opengis.net/gml/3.2}AbstractParametricCurveSurfaceType with content type EMPTY
class AbstractParametricCurveSurfaceType (AbstractSurfacePatchType):
    """Complex type {http://www.opengis.net/gml/3.2}AbstractParametricCurveSurfaceType with content type EMPTY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_EMPTY
    _Abstract = True
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractParametricCurveSurfaceType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 666, 1)
    _ElementMap = AbstractSurfacePatchType._ElementMap.copy()
    _AttributeMap = AbstractSurfacePatchType._AttributeMap.copy()
    # Base type is AbstractSurfacePatchType
    
    # Attribute aggregationType uses Python identifier aggregationType
    __aggregationType = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'aggregationType'), 'aggregationType', '__httpwww_opengis_netgml3_2_AbstractParametricCurveSurfaceType_aggregationType', _module_typeBindings.AggregationType)
    __aggregationType._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 158, 2)
    __aggregationType._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 158, 2)
    
    aggregationType = property(__aggregationType.value, __aggregationType.set, None, None)

    _ElementMap.update({
        
    })
    _AttributeMap.update({
        __aggregationType.name() : __aggregationType
    })
_module_typeBindings.AbstractParametricCurveSurfaceType = AbstractParametricCurveSurfaceType
_Namespace_gml.addCategoryObject('typeBinding', 'AbstractParametricCurveSurfaceType', AbstractParametricCurveSurfaceType)


# Complex type {http://www.opengis.net/gml/3.2}AbstractTimeObjectType with content type ELEMENT_ONLY
class AbstractTimeObjectType (AbstractGMLType):
    """Complex type {http://www.opengis.net/gml/3.2}AbstractTimeObjectType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = True
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractTimeObjectType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporal.xsd', 23, 1)
    _ElementMap = AbstractGMLType._ElementMap.copy()
    _AttributeMap = AbstractGMLType._AttributeMap.copy()
    # Base type is AbstractGMLType
    
    # Element metaDataProperty ({http://www.opengis.net/gml/3.2}metaDataProperty) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element description ({http://www.opengis.net/gml/3.2}description) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element descriptionReference ({http://www.opengis.net/gml/3.2}descriptionReference) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element name ({http://www.opengis.net/gml/3.2}name) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element identifier ({http://www.opengis.net/gml/3.2}identifier) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Attribute id inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    _ElementMap.update({
        
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.AbstractTimeObjectType = AbstractTimeObjectType
_Namespace_gml.addCategoryObject('typeBinding', 'AbstractTimeObjectType', AbstractTimeObjectType)


# Complex type {http://www.opengis.net/gml/3.2}TimePositionType with content type SIMPLE
class TimePositionType (pyxb.binding.basis.complexTypeDefinition):
    """The method for identifying a temporal position is specific to each temporal reference system.  gml:TimePositionType supports the description of temporal position according to the subtypes described in ISO 19108.
Values based on calendars and clocks use lexical formats that are based on ISO 8601, as described in XML Schema Part 2:2001. A decimal value may be used with coordinate systems such as GPS time or UNIX time. A URI may be used to provide a reference to some era in an ordinal reference system . 
In common with many of the components modelled as data types in the ISO 19100 series of International Standards, the corresponding GML component has simple content. However, the content model gml:TimePositionType is defined in several steps.
Three XML attributes appear on gml:TimePositionType:
A time value shall be associated with a temporal reference system through the frame attribute that provides a URI reference that identifies a description of the reference system. Following ISO 19108, the Gregorian calendar with UTC is the default reference system, but others may also be used. Components for describing temporal reference systems are described in 14.4, but it is not required that the reference system be described in this, as the reference may refer to anything that may be indentified with a URI.  
For time values using a calendar containing more than one era, the (optional) calendarEraName attribute provides the name of the calendar era.  
Inexact temporal positions may be expressed using the optional indeterminatePosition attribute.  This takes a value from an enumeration."""
    _TypeDefinition = TimePositionUnion
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_SIMPLE
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'TimePositionType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporal.xsd', 168, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is TimePositionUnion
    
    # Attribute frame uses Python identifier frame
    __frame = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'frame'), 'frame', '__httpwww_opengis_netgml3_2_TimePositionType_frame', pyxb.binding.datatypes.anyURI, unicode_default='#ISO-8601')
    __frame._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporal.xsd', 180, 4)
    __frame._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporal.xsd', 180, 4)
    
    frame = property(__frame.value, __frame.set, None, None)

    
    # Attribute calendarEraName uses Python identifier calendarEraName
    __calendarEraName = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'calendarEraName'), 'calendarEraName', '__httpwww_opengis_netgml3_2_TimePositionType_calendarEraName', pyxb.binding.datatypes.string)
    __calendarEraName._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporal.xsd', 181, 4)
    __calendarEraName._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporal.xsd', 181, 4)
    
    calendarEraName = property(__calendarEraName.value, __calendarEraName.set, None, None)

    
    # Attribute indeterminatePosition uses Python identifier indeterminatePosition
    __indeterminatePosition = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'indeterminatePosition'), 'indeterminatePosition', '__httpwww_opengis_netgml3_2_TimePositionType_indeterminatePosition', _module_typeBindings.TimeIndeterminateValueType)
    __indeterminatePosition._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporal.xsd', 182, 4)
    __indeterminatePosition._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporal.xsd', 182, 4)
    
    indeterminatePosition = property(__indeterminatePosition.value, __indeterminatePosition.set, None, None)

    _ElementMap.update({
        
    })
    _AttributeMap.update({
        __frame.name() : __frame,
        __calendarEraName.name() : __calendarEraName,
        __indeterminatePosition.name() : __indeterminatePosition
    })
_module_typeBindings.TimePositionType = TimePositionType
_Namespace_gml.addCategoryObject('typeBinding', 'TimePositionType', TimePositionType)


# Complex type {http://www.opengis.net/gml/3.2}AbstractTopologyType with content type ELEMENT_ONLY
class AbstractTopologyType (AbstractGMLType):
    """This abstract type supplies the root or base type for all topological elements including primitives and complexes. It inherits AbstractGMLType and hence can be identified using the gml:id attribute."""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = True
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractTopologyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/topology.xsd', 17, 2)
    _ElementMap = AbstractGMLType._ElementMap.copy()
    _AttributeMap = AbstractGMLType._AttributeMap.copy()
    # Base type is AbstractGMLType
    
    # Element metaDataProperty ({http://www.opengis.net/gml/3.2}metaDataProperty) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element description ({http://www.opengis.net/gml/3.2}description) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element descriptionReference ({http://www.opengis.net/gml/3.2}descriptionReference) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element name ({http://www.opengis.net/gml/3.2}name) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element identifier ({http://www.opengis.net/gml/3.2}identifier) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Attribute id inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    _ElementMap.update({
        
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.AbstractTopologyType = AbstractTopologyType
_Namespace_gml.addCategoryObject('typeBinding', 'AbstractTopologyType', AbstractTopologyType)


# Complex type {http://www.opengis.net/gml/3.2}CompositeValueType with content type ELEMENT_ONLY
class CompositeValueType (AbstractGMLType):
    """Complex type {http://www.opengis.net/gml/3.2}CompositeValueType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'CompositeValueType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/valueObjects.xsd', 130, 1)
    _ElementMap = AbstractGMLType._ElementMap.copy()
    _AttributeMap = AbstractGMLType._AttributeMap.copy()
    # Base type is AbstractGMLType
    
    # Element metaDataProperty ({http://www.opengis.net/gml/3.2}metaDataProperty) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element description ({http://www.opengis.net/gml/3.2}description) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element descriptionReference ({http://www.opengis.net/gml/3.2}descriptionReference) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element name ({http://www.opengis.net/gml/3.2}name) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element identifier ({http://www.opengis.net/gml/3.2}identifier) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element {http://www.opengis.net/gml/3.2}valueComponent uses Python identifier valueComponent
    __valueComponent = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'valueComponent'), 'valueComponent', '__httpwww_opengis_netgml3_2_CompositeValueType_httpwww_opengis_netgml3_2valueComponent', True, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/valueObjects.xsd', 102, 1), )

    
    valueComponent = property(__valueComponent.value, __valueComponent.set, None, 'Property that refers to, or contains, a Value.')

    
    # Element {http://www.opengis.net/gml/3.2}valueComponents uses Python identifier valueComponents
    __valueComponents = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'valueComponents'), 'valueComponents', '__httpwww_opengis_netgml3_2_CompositeValueType_httpwww_opengis_netgml3_2valueComponents', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/valueObjects.xsd', 114, 1), )

    
    valueComponents = property(__valueComponents.value, __valueComponents.set, None, 'Property that contains Values.')

    
    # Attribute id inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Attribute aggregationType uses Python identifier aggregationType
    __aggregationType = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'aggregationType'), 'aggregationType', '__httpwww_opengis_netgml3_2_CompositeValueType_aggregationType', _module_typeBindings.AggregationType)
    __aggregationType._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 158, 2)
    __aggregationType._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 158, 2)
    
    aggregationType = property(__aggregationType.value, __aggregationType.set, None, None)

    _ElementMap.update({
        __valueComponent.name() : __valueComponent,
        __valueComponents.name() : __valueComponents
    })
    _AttributeMap.update({
        __aggregationType.name() : __aggregationType
    })
_module_typeBindings.CompositeValueType = CompositeValueType
_Namespace_gml.addCategoryObject('typeBinding', 'CompositeValueType', CompositeValueType)


# Complex type {http://www.isotc211.org/2005/gco}TypeName_PropertyType with content type ELEMENT_ONLY
class TypeName_PropertyType (pyxb.binding.basis.complexTypeDefinition):
    """Complex type {http://www.isotc211.org/2005/gco}TypeName_PropertyType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gco, 'TypeName_PropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 32, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.isotc211.org/2005/gco}TypeName uses Python identifier TypeName
    __TypeName = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gco, 'TypeName'), 'TypeName', '__httpwww_isotc211_org2005gco_TypeName_PropertyType_httpwww_isotc211_org2005gcoTypeName', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 30, 1), )

    
    TypeName = property(__TypeName.value, __TypeName.set, None, None)

    
    # Attribute uuidref uses Python identifier uuidref
    __uuidref = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'uuidref'), 'uuidref', '__httpwww_isotc211_org2005gco_TypeName_PropertyType_uuidref', pyxb.binding.datatypes.string)
    __uuidref._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 30, 2)
    __uuidref._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 30, 2)
    
    uuidref = property(__uuidref.value, __uuidref.set, None, None)

    
    # Attribute {http://www.isotc211.org/2005/gco}nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gco, 'nilReason'), 'nilReason', '__httpwww_isotc211_org2005gco_TypeName_PropertyType_httpwww_isotc211_org2005gconilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 33, 1)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 37, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}type uses Python identifier type
    __type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'type'), 'type', '__httpwww_isotc211_org2005gco_TypeName_PropertyType_httpwww_w3_org1999xlinktype', _ImportedBinding_bindings_v1411_write__xlink.typeType, fixed=True, unicode_default='simple')
    __type._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 29, 1)
    __type._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 112, 2)
    
    type = property(__type.value, __type.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}href uses Python identifier href
    __href = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'href'), 'href', '__httpwww_isotc211_org2005gco_TypeName_PropertyType_httpwww_w3_org1999xlinkhref', _ImportedBinding_bindings_v1411_write__xlink.hrefType)
    __href._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 42, 1)
    __href._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 113, 2)
    
    href = property(__href.value, __href.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}role uses Python identifier role
    __role = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'role'), 'role', '__httpwww_isotc211_org2005gco_TypeName_PropertyType_httpwww_w3_org1999xlinkrole', _ImportedBinding_bindings_v1411_write__xlink.roleType)
    __role._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 48, 1)
    __role._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 114, 2)
    
    role = property(__role.value, __role.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}arcrole uses Python identifier arcrole
    __arcrole = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'arcrole'), 'arcrole', '__httpwww_isotc211_org2005gco_TypeName_PropertyType_httpwww_w3_org1999xlinkarcrole', _ImportedBinding_bindings_v1411_write__xlink.arcroleType)
    __arcrole._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 56, 1)
    __arcrole._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 115, 2)
    
    arcrole = property(__arcrole.value, __arcrole.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}title uses Python identifier title
    __title = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'title'), 'title', '__httpwww_isotc211_org2005gco_TypeName_PropertyType_httpwww_w3_org1999xlinktitle', _ImportedBinding_bindings_v1411_write__xlink.titleAttrType)
    __title._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 64, 1)
    __title._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 116, 2)
    
    title = property(__title.value, __title.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}show uses Python identifier show
    __show = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'show'), 'show', '__httpwww_isotc211_org2005gco_TypeName_PropertyType_httpwww_w3_org1999xlinkshow', _ImportedBinding_bindings_v1411_write__xlink.showType)
    __show._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 70, 1)
    __show._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 117, 2)
    
    show = property(__show.value, __show.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}actuate uses Python identifier actuate
    __actuate = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'actuate'), 'actuate', '__httpwww_isotc211_org2005gco_TypeName_PropertyType_httpwww_w3_org1999xlinkactuate', _ImportedBinding_bindings_v1411_write__xlink.actuateType)
    __actuate._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 82, 1)
    __actuate._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 118, 2)
    
    actuate = property(__actuate.value, __actuate.set, None, None)

    _ElementMap.update({
        __TypeName.name() : __TypeName
    })
    _AttributeMap.update({
        __uuidref.name() : __uuidref,
        __nilReason.name() : __nilReason,
        __type.name() : __type,
        __href.name() : __href,
        __role.name() : __role,
        __arcrole.name() : __arcrole,
        __title.name() : __title,
        __show.name() : __show,
        __actuate.name() : __actuate
    })
_module_typeBindings.TypeName_PropertyType = TypeName_PropertyType
_Namespace_gco.addCategoryObject('typeBinding', 'TypeName_PropertyType', TypeName_PropertyType)


# Complex type {http://www.isotc211.org/2005/gco}MemberName_PropertyType with content type ELEMENT_ONLY
class MemberName_PropertyType (pyxb.binding.basis.complexTypeDefinition):
    """Complex type {http://www.isotc211.org/2005/gco}MemberName_PropertyType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gco, 'MemberName_PropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 56, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.isotc211.org/2005/gco}MemberName uses Python identifier MemberName
    __MemberName = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gco, 'MemberName'), 'MemberName', '__httpwww_isotc211_org2005gco_MemberName_PropertyType_httpwww_isotc211_org2005gcoMemberName', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 54, 1), )

    
    MemberName = property(__MemberName.value, __MemberName.set, None, None)

    
    # Attribute uuidref uses Python identifier uuidref
    __uuidref = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'uuidref'), 'uuidref', '__httpwww_isotc211_org2005gco_MemberName_PropertyType_uuidref', pyxb.binding.datatypes.string)
    __uuidref._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 30, 2)
    __uuidref._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 30, 2)
    
    uuidref = property(__uuidref.value, __uuidref.set, None, None)

    
    # Attribute {http://www.isotc211.org/2005/gco}nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gco, 'nilReason'), 'nilReason', '__httpwww_isotc211_org2005gco_MemberName_PropertyType_httpwww_isotc211_org2005gconilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 33, 1)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 61, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}type uses Python identifier type
    __type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'type'), 'type', '__httpwww_isotc211_org2005gco_MemberName_PropertyType_httpwww_w3_org1999xlinktype', _ImportedBinding_bindings_v1411_write__xlink.typeType, fixed=True, unicode_default='simple')
    __type._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 29, 1)
    __type._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 112, 2)
    
    type = property(__type.value, __type.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}href uses Python identifier href
    __href = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'href'), 'href', '__httpwww_isotc211_org2005gco_MemberName_PropertyType_httpwww_w3_org1999xlinkhref', _ImportedBinding_bindings_v1411_write__xlink.hrefType)
    __href._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 42, 1)
    __href._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 113, 2)
    
    href = property(__href.value, __href.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}role uses Python identifier role
    __role = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'role'), 'role', '__httpwww_isotc211_org2005gco_MemberName_PropertyType_httpwww_w3_org1999xlinkrole', _ImportedBinding_bindings_v1411_write__xlink.roleType)
    __role._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 48, 1)
    __role._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 114, 2)
    
    role = property(__role.value, __role.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}arcrole uses Python identifier arcrole
    __arcrole = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'arcrole'), 'arcrole', '__httpwww_isotc211_org2005gco_MemberName_PropertyType_httpwww_w3_org1999xlinkarcrole', _ImportedBinding_bindings_v1411_write__xlink.arcroleType)
    __arcrole._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 56, 1)
    __arcrole._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 115, 2)
    
    arcrole = property(__arcrole.value, __arcrole.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}title uses Python identifier title
    __title = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'title'), 'title', '__httpwww_isotc211_org2005gco_MemberName_PropertyType_httpwww_w3_org1999xlinktitle', _ImportedBinding_bindings_v1411_write__xlink.titleAttrType)
    __title._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 64, 1)
    __title._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 116, 2)
    
    title = property(__title.value, __title.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}show uses Python identifier show
    __show = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'show'), 'show', '__httpwww_isotc211_org2005gco_MemberName_PropertyType_httpwww_w3_org1999xlinkshow', _ImportedBinding_bindings_v1411_write__xlink.showType)
    __show._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 70, 1)
    __show._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 117, 2)
    
    show = property(__show.value, __show.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}actuate uses Python identifier actuate
    __actuate = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'actuate'), 'actuate', '__httpwww_isotc211_org2005gco_MemberName_PropertyType_httpwww_w3_org1999xlinkactuate', _ImportedBinding_bindings_v1411_write__xlink.actuateType)
    __actuate._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 82, 1)
    __actuate._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 118, 2)
    
    actuate = property(__actuate.value, __actuate.set, None, None)

    _ElementMap.update({
        __MemberName.name() : __MemberName
    })
    _AttributeMap.update({
        __uuidref.name() : __uuidref,
        __nilReason.name() : __nilReason,
        __type.name() : __type,
        __href.name() : __href,
        __role.name() : __role,
        __arcrole.name() : __arcrole,
        __title.name() : __title,
        __show.name() : __show,
        __actuate.name() : __actuate
    })
_module_typeBindings.MemberName_PropertyType = MemberName_PropertyType
_Namespace_gco.addCategoryObject('typeBinding', 'MemberName_PropertyType', MemberName_PropertyType)


# Complex type {http://www.isotc211.org/2005/gco}Multiplicity_PropertyType with content type ELEMENT_ONLY
class Multiplicity_PropertyType (pyxb.binding.basis.complexTypeDefinition):
    """Complex type {http://www.isotc211.org/2005/gco}Multiplicity_PropertyType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gco, 'Multiplicity_PropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 79, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.isotc211.org/2005/gco}Multiplicity uses Python identifier Multiplicity
    __Multiplicity = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gco, 'Multiplicity'), 'Multiplicity', '__httpwww_isotc211_org2005gco_Multiplicity_PropertyType_httpwww_isotc211_org2005gcoMultiplicity', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 77, 1), )

    
    Multiplicity = property(__Multiplicity.value, __Multiplicity.set, None, None)

    
    # Attribute uuidref uses Python identifier uuidref
    __uuidref = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'uuidref'), 'uuidref', '__httpwww_isotc211_org2005gco_Multiplicity_PropertyType_uuidref', pyxb.binding.datatypes.string)
    __uuidref._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 30, 2)
    __uuidref._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 30, 2)
    
    uuidref = property(__uuidref.value, __uuidref.set, None, None)

    
    # Attribute {http://www.isotc211.org/2005/gco}nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gco, 'nilReason'), 'nilReason', '__httpwww_isotc211_org2005gco_Multiplicity_PropertyType_httpwww_isotc211_org2005gconilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 33, 1)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 84, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}type uses Python identifier type
    __type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'type'), 'type', '__httpwww_isotc211_org2005gco_Multiplicity_PropertyType_httpwww_w3_org1999xlinktype', _ImportedBinding_bindings_v1411_write__xlink.typeType, fixed=True, unicode_default='simple')
    __type._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 29, 1)
    __type._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 112, 2)
    
    type = property(__type.value, __type.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}href uses Python identifier href
    __href = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'href'), 'href', '__httpwww_isotc211_org2005gco_Multiplicity_PropertyType_httpwww_w3_org1999xlinkhref', _ImportedBinding_bindings_v1411_write__xlink.hrefType)
    __href._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 42, 1)
    __href._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 113, 2)
    
    href = property(__href.value, __href.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}role uses Python identifier role
    __role = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'role'), 'role', '__httpwww_isotc211_org2005gco_Multiplicity_PropertyType_httpwww_w3_org1999xlinkrole', _ImportedBinding_bindings_v1411_write__xlink.roleType)
    __role._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 48, 1)
    __role._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 114, 2)
    
    role = property(__role.value, __role.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}arcrole uses Python identifier arcrole
    __arcrole = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'arcrole'), 'arcrole', '__httpwww_isotc211_org2005gco_Multiplicity_PropertyType_httpwww_w3_org1999xlinkarcrole', _ImportedBinding_bindings_v1411_write__xlink.arcroleType)
    __arcrole._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 56, 1)
    __arcrole._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 115, 2)
    
    arcrole = property(__arcrole.value, __arcrole.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}title uses Python identifier title
    __title = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'title'), 'title', '__httpwww_isotc211_org2005gco_Multiplicity_PropertyType_httpwww_w3_org1999xlinktitle', _ImportedBinding_bindings_v1411_write__xlink.titleAttrType)
    __title._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 64, 1)
    __title._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 116, 2)
    
    title = property(__title.value, __title.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}show uses Python identifier show
    __show = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'show'), 'show', '__httpwww_isotc211_org2005gco_Multiplicity_PropertyType_httpwww_w3_org1999xlinkshow', _ImportedBinding_bindings_v1411_write__xlink.showType)
    __show._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 70, 1)
    __show._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 117, 2)
    
    show = property(__show.value, __show.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}actuate uses Python identifier actuate
    __actuate = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'actuate'), 'actuate', '__httpwww_isotc211_org2005gco_Multiplicity_PropertyType_httpwww_w3_org1999xlinkactuate', _ImportedBinding_bindings_v1411_write__xlink.actuateType)
    __actuate._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 82, 1)
    __actuate._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 118, 2)
    
    actuate = property(__actuate.value, __actuate.set, None, None)

    _ElementMap.update({
        __Multiplicity.name() : __Multiplicity
    })
    _AttributeMap.update({
        __uuidref.name() : __uuidref,
        __nilReason.name() : __nilReason,
        __type.name() : __type,
        __href.name() : __href,
        __role.name() : __role,
        __arcrole.name() : __arcrole,
        __title.name() : __title,
        __show.name() : __show,
        __actuate.name() : __actuate
    })
_module_typeBindings.Multiplicity_PropertyType = Multiplicity_PropertyType
_Namespace_gco.addCategoryObject('typeBinding', 'Multiplicity_PropertyType', Multiplicity_PropertyType)


# Complex type {http://www.isotc211.org/2005/gco}MultiplicityRange_PropertyType with content type ELEMENT_ONLY
class MultiplicityRange_PropertyType (pyxb.binding.basis.complexTypeDefinition):
    """Complex type {http://www.isotc211.org/2005/gco}MultiplicityRange_PropertyType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gco, 'MultiplicityRange_PropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 103, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.isotc211.org/2005/gco}MultiplicityRange uses Python identifier MultiplicityRange
    __MultiplicityRange = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gco, 'MultiplicityRange'), 'MultiplicityRange', '__httpwww_isotc211_org2005gco_MultiplicityRange_PropertyType_httpwww_isotc211_org2005gcoMultiplicityRange', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 101, 1), )

    
    MultiplicityRange = property(__MultiplicityRange.value, __MultiplicityRange.set, None, None)

    
    # Attribute uuidref uses Python identifier uuidref
    __uuidref = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'uuidref'), 'uuidref', '__httpwww_isotc211_org2005gco_MultiplicityRange_PropertyType_uuidref', pyxb.binding.datatypes.string)
    __uuidref._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 30, 2)
    __uuidref._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 30, 2)
    
    uuidref = property(__uuidref.value, __uuidref.set, None, None)

    
    # Attribute {http://www.isotc211.org/2005/gco}nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gco, 'nilReason'), 'nilReason', '__httpwww_isotc211_org2005gco_MultiplicityRange_PropertyType_httpwww_isotc211_org2005gconilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 33, 1)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 108, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}type uses Python identifier type
    __type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'type'), 'type', '__httpwww_isotc211_org2005gco_MultiplicityRange_PropertyType_httpwww_w3_org1999xlinktype', _ImportedBinding_bindings_v1411_write__xlink.typeType, fixed=True, unicode_default='simple')
    __type._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 29, 1)
    __type._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 112, 2)
    
    type = property(__type.value, __type.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}href uses Python identifier href
    __href = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'href'), 'href', '__httpwww_isotc211_org2005gco_MultiplicityRange_PropertyType_httpwww_w3_org1999xlinkhref', _ImportedBinding_bindings_v1411_write__xlink.hrefType)
    __href._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 42, 1)
    __href._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 113, 2)
    
    href = property(__href.value, __href.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}role uses Python identifier role
    __role = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'role'), 'role', '__httpwww_isotc211_org2005gco_MultiplicityRange_PropertyType_httpwww_w3_org1999xlinkrole', _ImportedBinding_bindings_v1411_write__xlink.roleType)
    __role._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 48, 1)
    __role._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 114, 2)
    
    role = property(__role.value, __role.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}arcrole uses Python identifier arcrole
    __arcrole = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'arcrole'), 'arcrole', '__httpwww_isotc211_org2005gco_MultiplicityRange_PropertyType_httpwww_w3_org1999xlinkarcrole', _ImportedBinding_bindings_v1411_write__xlink.arcroleType)
    __arcrole._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 56, 1)
    __arcrole._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 115, 2)
    
    arcrole = property(__arcrole.value, __arcrole.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}title uses Python identifier title
    __title = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'title'), 'title', '__httpwww_isotc211_org2005gco_MultiplicityRange_PropertyType_httpwww_w3_org1999xlinktitle', _ImportedBinding_bindings_v1411_write__xlink.titleAttrType)
    __title._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 64, 1)
    __title._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 116, 2)
    
    title = property(__title.value, __title.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}show uses Python identifier show
    __show = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'show'), 'show', '__httpwww_isotc211_org2005gco_MultiplicityRange_PropertyType_httpwww_w3_org1999xlinkshow', _ImportedBinding_bindings_v1411_write__xlink.showType)
    __show._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 70, 1)
    __show._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 117, 2)
    
    show = property(__show.value, __show.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}actuate uses Python identifier actuate
    __actuate = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'actuate'), 'actuate', '__httpwww_isotc211_org2005gco_MultiplicityRange_PropertyType_httpwww_w3_org1999xlinkactuate', _ImportedBinding_bindings_v1411_write__xlink.actuateType)
    __actuate._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 82, 1)
    __actuate._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 118, 2)
    
    actuate = property(__actuate.value, __actuate.set, None, None)

    _ElementMap.update({
        __MultiplicityRange.name() : __MultiplicityRange
    })
    _AttributeMap.update({
        __uuidref.name() : __uuidref,
        __nilReason.name() : __nilReason,
        __type.name() : __type,
        __href.name() : __href,
        __role.name() : __role,
        __arcrole.name() : __arcrole,
        __title.name() : __title,
        __show.name() : __show,
        __actuate.name() : __actuate
    })
_module_typeBindings.MultiplicityRange_PropertyType = MultiplicityRange_PropertyType
_Namespace_gco.addCategoryObject('typeBinding', 'MultiplicityRange_PropertyType', MultiplicityRange_PropertyType)


# Complex type {http://www.isotc211.org/2005/gco}Measure_PropertyType with content type ELEMENT_ONLY
class Measure_PropertyType (pyxb.binding.basis.complexTypeDefinition):
    """Complex type {http://www.isotc211.org/2005/gco}Measure_PropertyType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gco, 'Measure_PropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 115, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.isotc211.org/2005/gco}Measure uses Python identifier Measure
    __Measure = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gco, 'Measure'), 'Measure', '__httpwww_isotc211_org2005gco_Measure_PropertyType_httpwww_isotc211_org2005gcoMeasure', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 113, 1), )

    
    Measure = property(__Measure.value, __Measure.set, None, None)

    
    # Attribute {http://www.isotc211.org/2005/gco}nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gco, 'nilReason'), 'nilReason', '__httpwww_isotc211_org2005gco_Measure_PropertyType_httpwww_isotc211_org2005gconilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 33, 1)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 119, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    _ElementMap.update({
        __Measure.name() : __Measure
    })
    _AttributeMap.update({
        __nilReason.name() : __nilReason
    })
_module_typeBindings.Measure_PropertyType = Measure_PropertyType
_Namespace_gco.addCategoryObject('typeBinding', 'Measure_PropertyType', Measure_PropertyType)


# Complex type {http://www.isotc211.org/2005/gco}Length_PropertyType with content type ELEMENT_ONLY
class Length_PropertyType (pyxb.binding.basis.complexTypeDefinition):
    """Complex type {http://www.isotc211.org/2005/gco}Length_PropertyType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gco, 'Length_PropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 125, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.isotc211.org/2005/gco}Length uses Python identifier Length
    __Length = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gco, 'Length'), 'Length', '__httpwww_isotc211_org2005gco_Length_PropertyType_httpwww_isotc211_org2005gcoLength', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 123, 1), )

    
    Length = property(__Length.value, __Length.set, None, None)

    
    # Attribute {http://www.isotc211.org/2005/gco}nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gco, 'nilReason'), 'nilReason', '__httpwww_isotc211_org2005gco_Length_PropertyType_httpwww_isotc211_org2005gconilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 33, 1)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 129, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    _ElementMap.update({
        __Length.name() : __Length
    })
    _AttributeMap.update({
        __nilReason.name() : __nilReason
    })
_module_typeBindings.Length_PropertyType = Length_PropertyType
_Namespace_gco.addCategoryObject('typeBinding', 'Length_PropertyType', Length_PropertyType)


# Complex type {http://www.isotc211.org/2005/gco}Angle_PropertyType with content type ELEMENT_ONLY
class Angle_PropertyType (pyxb.binding.basis.complexTypeDefinition):
    """Complex type {http://www.isotc211.org/2005/gco}Angle_PropertyType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gco, 'Angle_PropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 135, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.isotc211.org/2005/gco}Angle uses Python identifier Angle
    __Angle = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gco, 'Angle'), 'Angle', '__httpwww_isotc211_org2005gco_Angle_PropertyType_httpwww_isotc211_org2005gcoAngle', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 133, 1), )

    
    Angle = property(__Angle.value, __Angle.set, None, None)

    
    # Attribute {http://www.isotc211.org/2005/gco}nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gco, 'nilReason'), 'nilReason', '__httpwww_isotc211_org2005gco_Angle_PropertyType_httpwww_isotc211_org2005gconilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 33, 1)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 139, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    _ElementMap.update({
        __Angle.name() : __Angle
    })
    _AttributeMap.update({
        __nilReason.name() : __nilReason
    })
_module_typeBindings.Angle_PropertyType = Angle_PropertyType
_Namespace_gco.addCategoryObject('typeBinding', 'Angle_PropertyType', Angle_PropertyType)


# Complex type {http://www.isotc211.org/2005/gco}Scale_PropertyType with content type ELEMENT_ONLY
class Scale_PropertyType (pyxb.binding.basis.complexTypeDefinition):
    """Complex type {http://www.isotc211.org/2005/gco}Scale_PropertyType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gco, 'Scale_PropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 145, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.isotc211.org/2005/gco}Scale uses Python identifier Scale
    __Scale = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gco, 'Scale'), 'Scale', '__httpwww_isotc211_org2005gco_Scale_PropertyType_httpwww_isotc211_org2005gcoScale', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 143, 1), )

    
    Scale = property(__Scale.value, __Scale.set, None, None)

    
    # Attribute {http://www.isotc211.org/2005/gco}nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gco, 'nilReason'), 'nilReason', '__httpwww_isotc211_org2005gco_Scale_PropertyType_httpwww_isotc211_org2005gconilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 33, 1)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 149, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    _ElementMap.update({
        __Scale.name() : __Scale
    })
    _AttributeMap.update({
        __nilReason.name() : __nilReason
    })
_module_typeBindings.Scale_PropertyType = Scale_PropertyType
_Namespace_gco.addCategoryObject('typeBinding', 'Scale_PropertyType', Scale_PropertyType)


# Complex type {http://www.isotc211.org/2005/gco}Distance_PropertyType with content type ELEMENT_ONLY
class Distance_PropertyType (pyxb.binding.basis.complexTypeDefinition):
    """Complex type {http://www.isotc211.org/2005/gco}Distance_PropertyType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gco, 'Distance_PropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 155, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.isotc211.org/2005/gco}Distance uses Python identifier Distance
    __Distance = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gco, 'Distance'), 'Distance', '__httpwww_isotc211_org2005gco_Distance_PropertyType_httpwww_isotc211_org2005gcoDistance', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 153, 1), )

    
    Distance = property(__Distance.value, __Distance.set, None, None)

    
    # Attribute {http://www.isotc211.org/2005/gco}nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gco, 'nilReason'), 'nilReason', '__httpwww_isotc211_org2005gco_Distance_PropertyType_httpwww_isotc211_org2005gconilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 33, 1)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 159, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    _ElementMap.update({
        __Distance.name() : __Distance
    })
    _AttributeMap.update({
        __nilReason.name() : __nilReason
    })
_module_typeBindings.Distance_PropertyType = Distance_PropertyType
_Namespace_gco.addCategoryObject('typeBinding', 'Distance_PropertyType', Distance_PropertyType)


# Complex type {http://www.isotc211.org/2005/gco}CharacterString_PropertyType with content type ELEMENT_ONLY
class CharacterString_PropertyType (pyxb.binding.basis.complexTypeDefinition):
    """Complex type {http://www.isotc211.org/2005/gco}CharacterString_PropertyType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gco, 'CharacterString_PropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 165, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.isotc211.org/2005/gco}CharacterString uses Python identifier CharacterString
    __CharacterString = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gco, 'CharacterString'), 'CharacterString', '__httpwww_isotc211_org2005gco_CharacterString_PropertyType_httpwww_isotc211_org2005gcoCharacterString', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 163, 1), )

    
    CharacterString = property(__CharacterString.value, __CharacterString.set, None, None)

    
    # Attribute {http://www.isotc211.org/2005/gco}nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gco, 'nilReason'), 'nilReason', '__httpwww_isotc211_org2005gco_CharacterString_PropertyType_httpwww_isotc211_org2005gconilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 33, 1)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 169, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    _ElementMap.update({
        __CharacterString.name() : __CharacterString
    })
    _AttributeMap.update({
        __nilReason.name() : __nilReason
    })
_module_typeBindings.CharacterString_PropertyType = CharacterString_PropertyType
_Namespace_gco.addCategoryObject('typeBinding', 'CharacterString_PropertyType', CharacterString_PropertyType)


# Complex type {http://www.isotc211.org/2005/gco}Boolean_PropertyType with content type ELEMENT_ONLY
class Boolean_PropertyType (pyxb.binding.basis.complexTypeDefinition):
    """Complex type {http://www.isotc211.org/2005/gco}Boolean_PropertyType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gco, 'Boolean_PropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 175, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.isotc211.org/2005/gco}Boolean uses Python identifier Boolean
    __Boolean = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gco, 'Boolean'), 'Boolean', '__httpwww_isotc211_org2005gco_Boolean_PropertyType_httpwww_isotc211_org2005gcoBoolean', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 173, 1), )

    
    Boolean = property(__Boolean.value, __Boolean.set, None, None)

    
    # Attribute {http://www.isotc211.org/2005/gco}nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gco, 'nilReason'), 'nilReason', '__httpwww_isotc211_org2005gco_Boolean_PropertyType_httpwww_isotc211_org2005gconilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 33, 1)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 179, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    _ElementMap.update({
        __Boolean.name() : __Boolean
    })
    _AttributeMap.update({
        __nilReason.name() : __nilReason
    })
_module_typeBindings.Boolean_PropertyType = Boolean_PropertyType
_Namespace_gco.addCategoryObject('typeBinding', 'Boolean_PropertyType', Boolean_PropertyType)


# Complex type {http://www.isotc211.org/2005/gco}GenericName_PropertyType with content type ELEMENT_ONLY
class GenericName_PropertyType (pyxb.binding.basis.complexTypeDefinition):
    """Complex type {http://www.isotc211.org/2005/gco}GenericName_PropertyType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gco, 'GenericName_PropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 185, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.isotc211.org/2005/gco}AbstractGenericName uses Python identifier AbstractGenericName
    __AbstractGenericName = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gco, 'AbstractGenericName'), 'AbstractGenericName', '__httpwww_isotc211_org2005gco_GenericName_PropertyType_httpwww_isotc211_org2005gcoAbstractGenericName', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 183, 1), )

    
    AbstractGenericName = property(__AbstractGenericName.value, __AbstractGenericName.set, None, None)

    
    # Attribute {http://www.isotc211.org/2005/gco}nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gco, 'nilReason'), 'nilReason', '__httpwww_isotc211_org2005gco_GenericName_PropertyType_httpwww_isotc211_org2005gconilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 33, 1)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 189, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    _ElementMap.update({
        __AbstractGenericName.name() : __AbstractGenericName
    })
    _AttributeMap.update({
        __nilReason.name() : __nilReason
    })
_module_typeBindings.GenericName_PropertyType = GenericName_PropertyType
_Namespace_gco.addCategoryObject('typeBinding', 'GenericName_PropertyType', GenericName_PropertyType)


# Complex type {http://www.isotc211.org/2005/gco}LocalName_PropertyType with content type ELEMENT_ONLY
class LocalName_PropertyType (pyxb.binding.basis.complexTypeDefinition):
    """Complex type {http://www.isotc211.org/2005/gco}LocalName_PropertyType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gco, 'LocalName_PropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 195, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.isotc211.org/2005/gco}LocalName uses Python identifier LocalName
    __LocalName = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gco, 'LocalName'), 'LocalName', '__httpwww_isotc211_org2005gco_LocalName_PropertyType_httpwww_isotc211_org2005gcoLocalName', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 193, 1), )

    
    LocalName = property(__LocalName.value, __LocalName.set, None, None)

    
    # Attribute {http://www.isotc211.org/2005/gco}nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gco, 'nilReason'), 'nilReason', '__httpwww_isotc211_org2005gco_LocalName_PropertyType_httpwww_isotc211_org2005gconilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 33, 1)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 199, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    _ElementMap.update({
        __LocalName.name() : __LocalName
    })
    _AttributeMap.update({
        __nilReason.name() : __nilReason
    })
_module_typeBindings.LocalName_PropertyType = LocalName_PropertyType
_Namespace_gco.addCategoryObject('typeBinding', 'LocalName_PropertyType', LocalName_PropertyType)


# Complex type {http://www.isotc211.org/2005/gco}ScopedName_PropertyType with content type ELEMENT_ONLY
class ScopedName_PropertyType (pyxb.binding.basis.complexTypeDefinition):
    """Complex type {http://www.isotc211.org/2005/gco}ScopedName_PropertyType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gco, 'ScopedName_PropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 205, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.isotc211.org/2005/gco}ScopedName uses Python identifier ScopedName
    __ScopedName = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gco, 'ScopedName'), 'ScopedName', '__httpwww_isotc211_org2005gco_ScopedName_PropertyType_httpwww_isotc211_org2005gcoScopedName', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 203, 1), )

    
    ScopedName = property(__ScopedName.value, __ScopedName.set, None, None)

    
    # Attribute {http://www.isotc211.org/2005/gco}nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gco, 'nilReason'), 'nilReason', '__httpwww_isotc211_org2005gco_ScopedName_PropertyType_httpwww_isotc211_org2005gconilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 33, 1)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 209, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    _ElementMap.update({
        __ScopedName.name() : __ScopedName
    })
    _AttributeMap.update({
        __nilReason.name() : __nilReason
    })
_module_typeBindings.ScopedName_PropertyType = ScopedName_PropertyType
_Namespace_gco.addCategoryObject('typeBinding', 'ScopedName_PropertyType', ScopedName_PropertyType)


# Complex type {http://www.isotc211.org/2005/gco}UomAngle_PropertyType with content type ELEMENT_ONLY
class UomAngle_PropertyType (pyxb.binding.basis.complexTypeDefinition):
    """Complex type {http://www.isotc211.org/2005/gco}UomAngle_PropertyType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gco, 'UomAngle_PropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 215, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.opengis.net/gml/3.2}UnitDefinition uses Python identifier UnitDefinition
    __UnitDefinition = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'UnitDefinition'), 'UnitDefinition', '__httpwww_isotc211_org2005gco_UomAngle_PropertyType_httpwww_opengis_netgml3_2UnitDefinition', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/units.xsd', 30, 1), )

    
    UnitDefinition = property(__UnitDefinition.value, __UnitDefinition.set, None, 'A gml:UnitDefinition is a general definition of a unit of measure. This generic element is used only for units for which no relationship with other units or units systems is known.\nThe content model of gml:UnitDefinition adds three additional properties to gml:Definition, gml:quantityType, gml:quantityTypeReference and gml:catalogSymbol.  \nThe gml:catalogSymbol property optionally gives the short symbol used for this unit. This element is usually used when the relationship of this unit to other units or units systems is unknown.')

    
    # Attribute uuidref uses Python identifier uuidref
    __uuidref = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'uuidref'), 'uuidref', '__httpwww_isotc211_org2005gco_UomAngle_PropertyType_uuidref', pyxb.binding.datatypes.string)
    __uuidref._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 30, 2)
    __uuidref._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 30, 2)
    
    uuidref = property(__uuidref.value, __uuidref.set, None, None)

    
    # Attribute {http://www.isotc211.org/2005/gco}nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gco, 'nilReason'), 'nilReason', '__httpwww_isotc211_org2005gco_UomAngle_PropertyType_httpwww_isotc211_org2005gconilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 33, 1)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 220, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}type uses Python identifier type
    __type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'type'), 'type', '__httpwww_isotc211_org2005gco_UomAngle_PropertyType_httpwww_w3_org1999xlinktype', _ImportedBinding_bindings_v1411_write__xlink.typeType, fixed=True, unicode_default='simple')
    __type._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 29, 1)
    __type._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 112, 2)
    
    type = property(__type.value, __type.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}href uses Python identifier href
    __href = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'href'), 'href', '__httpwww_isotc211_org2005gco_UomAngle_PropertyType_httpwww_w3_org1999xlinkhref', _ImportedBinding_bindings_v1411_write__xlink.hrefType)
    __href._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 42, 1)
    __href._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 113, 2)
    
    href = property(__href.value, __href.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}role uses Python identifier role
    __role = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'role'), 'role', '__httpwww_isotc211_org2005gco_UomAngle_PropertyType_httpwww_w3_org1999xlinkrole', _ImportedBinding_bindings_v1411_write__xlink.roleType)
    __role._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 48, 1)
    __role._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 114, 2)
    
    role = property(__role.value, __role.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}arcrole uses Python identifier arcrole
    __arcrole = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'arcrole'), 'arcrole', '__httpwww_isotc211_org2005gco_UomAngle_PropertyType_httpwww_w3_org1999xlinkarcrole', _ImportedBinding_bindings_v1411_write__xlink.arcroleType)
    __arcrole._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 56, 1)
    __arcrole._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 115, 2)
    
    arcrole = property(__arcrole.value, __arcrole.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}title uses Python identifier title
    __title = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'title'), 'title', '__httpwww_isotc211_org2005gco_UomAngle_PropertyType_httpwww_w3_org1999xlinktitle', _ImportedBinding_bindings_v1411_write__xlink.titleAttrType)
    __title._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 64, 1)
    __title._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 116, 2)
    
    title = property(__title.value, __title.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}show uses Python identifier show
    __show = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'show'), 'show', '__httpwww_isotc211_org2005gco_UomAngle_PropertyType_httpwww_w3_org1999xlinkshow', _ImportedBinding_bindings_v1411_write__xlink.showType)
    __show._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 70, 1)
    __show._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 117, 2)
    
    show = property(__show.value, __show.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}actuate uses Python identifier actuate
    __actuate = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'actuate'), 'actuate', '__httpwww_isotc211_org2005gco_UomAngle_PropertyType_httpwww_w3_org1999xlinkactuate', _ImportedBinding_bindings_v1411_write__xlink.actuateType)
    __actuate._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 82, 1)
    __actuate._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 118, 2)
    
    actuate = property(__actuate.value, __actuate.set, None, None)

    _ElementMap.update({
        __UnitDefinition.name() : __UnitDefinition
    })
    _AttributeMap.update({
        __uuidref.name() : __uuidref,
        __nilReason.name() : __nilReason,
        __type.name() : __type,
        __href.name() : __href,
        __role.name() : __role,
        __arcrole.name() : __arcrole,
        __title.name() : __title,
        __show.name() : __show,
        __actuate.name() : __actuate
    })
_module_typeBindings.UomAngle_PropertyType = UomAngle_PropertyType
_Namespace_gco.addCategoryObject('typeBinding', 'UomAngle_PropertyType', UomAngle_PropertyType)


# Complex type {http://www.isotc211.org/2005/gco}UomLength_PropertyType with content type ELEMENT_ONLY
class UomLength_PropertyType (pyxb.binding.basis.complexTypeDefinition):
    """Complex type {http://www.isotc211.org/2005/gco}UomLength_PropertyType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gco, 'UomLength_PropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 225, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.opengis.net/gml/3.2}UnitDefinition uses Python identifier UnitDefinition
    __UnitDefinition = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'UnitDefinition'), 'UnitDefinition', '__httpwww_isotc211_org2005gco_UomLength_PropertyType_httpwww_opengis_netgml3_2UnitDefinition', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/units.xsd', 30, 1), )

    
    UnitDefinition = property(__UnitDefinition.value, __UnitDefinition.set, None, 'A gml:UnitDefinition is a general definition of a unit of measure. This generic element is used only for units for which no relationship with other units or units systems is known.\nThe content model of gml:UnitDefinition adds three additional properties to gml:Definition, gml:quantityType, gml:quantityTypeReference and gml:catalogSymbol.  \nThe gml:catalogSymbol property optionally gives the short symbol used for this unit. This element is usually used when the relationship of this unit to other units or units systems is unknown.')

    
    # Attribute uuidref uses Python identifier uuidref
    __uuidref = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'uuidref'), 'uuidref', '__httpwww_isotc211_org2005gco_UomLength_PropertyType_uuidref', pyxb.binding.datatypes.string)
    __uuidref._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 30, 2)
    __uuidref._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 30, 2)
    
    uuidref = property(__uuidref.value, __uuidref.set, None, None)

    
    # Attribute {http://www.isotc211.org/2005/gco}nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gco, 'nilReason'), 'nilReason', '__httpwww_isotc211_org2005gco_UomLength_PropertyType_httpwww_isotc211_org2005gconilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 33, 1)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 230, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}type uses Python identifier type
    __type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'type'), 'type', '__httpwww_isotc211_org2005gco_UomLength_PropertyType_httpwww_w3_org1999xlinktype', _ImportedBinding_bindings_v1411_write__xlink.typeType, fixed=True, unicode_default='simple')
    __type._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 29, 1)
    __type._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 112, 2)
    
    type = property(__type.value, __type.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}href uses Python identifier href
    __href = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'href'), 'href', '__httpwww_isotc211_org2005gco_UomLength_PropertyType_httpwww_w3_org1999xlinkhref', _ImportedBinding_bindings_v1411_write__xlink.hrefType)
    __href._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 42, 1)
    __href._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 113, 2)
    
    href = property(__href.value, __href.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}role uses Python identifier role
    __role = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'role'), 'role', '__httpwww_isotc211_org2005gco_UomLength_PropertyType_httpwww_w3_org1999xlinkrole', _ImportedBinding_bindings_v1411_write__xlink.roleType)
    __role._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 48, 1)
    __role._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 114, 2)
    
    role = property(__role.value, __role.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}arcrole uses Python identifier arcrole
    __arcrole = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'arcrole'), 'arcrole', '__httpwww_isotc211_org2005gco_UomLength_PropertyType_httpwww_w3_org1999xlinkarcrole', _ImportedBinding_bindings_v1411_write__xlink.arcroleType)
    __arcrole._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 56, 1)
    __arcrole._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 115, 2)
    
    arcrole = property(__arcrole.value, __arcrole.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}title uses Python identifier title
    __title = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'title'), 'title', '__httpwww_isotc211_org2005gco_UomLength_PropertyType_httpwww_w3_org1999xlinktitle', _ImportedBinding_bindings_v1411_write__xlink.titleAttrType)
    __title._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 64, 1)
    __title._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 116, 2)
    
    title = property(__title.value, __title.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}show uses Python identifier show
    __show = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'show'), 'show', '__httpwww_isotc211_org2005gco_UomLength_PropertyType_httpwww_w3_org1999xlinkshow', _ImportedBinding_bindings_v1411_write__xlink.showType)
    __show._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 70, 1)
    __show._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 117, 2)
    
    show = property(__show.value, __show.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}actuate uses Python identifier actuate
    __actuate = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'actuate'), 'actuate', '__httpwww_isotc211_org2005gco_UomLength_PropertyType_httpwww_w3_org1999xlinkactuate', _ImportedBinding_bindings_v1411_write__xlink.actuateType)
    __actuate._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 82, 1)
    __actuate._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 118, 2)
    
    actuate = property(__actuate.value, __actuate.set, None, None)

    _ElementMap.update({
        __UnitDefinition.name() : __UnitDefinition
    })
    _AttributeMap.update({
        __uuidref.name() : __uuidref,
        __nilReason.name() : __nilReason,
        __type.name() : __type,
        __href.name() : __href,
        __role.name() : __role,
        __arcrole.name() : __arcrole,
        __title.name() : __title,
        __show.name() : __show,
        __actuate.name() : __actuate
    })
_module_typeBindings.UomLength_PropertyType = UomLength_PropertyType
_Namespace_gco.addCategoryObject('typeBinding', 'UomLength_PropertyType', UomLength_PropertyType)


# Complex type {http://www.isotc211.org/2005/gco}UomScale_PropertyType with content type ELEMENT_ONLY
class UomScale_PropertyType (pyxb.binding.basis.complexTypeDefinition):
    """Complex type {http://www.isotc211.org/2005/gco}UomScale_PropertyType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gco, 'UomScale_PropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 235, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.opengis.net/gml/3.2}UnitDefinition uses Python identifier UnitDefinition
    __UnitDefinition = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'UnitDefinition'), 'UnitDefinition', '__httpwww_isotc211_org2005gco_UomScale_PropertyType_httpwww_opengis_netgml3_2UnitDefinition', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/units.xsd', 30, 1), )

    
    UnitDefinition = property(__UnitDefinition.value, __UnitDefinition.set, None, 'A gml:UnitDefinition is a general definition of a unit of measure. This generic element is used only for units for which no relationship with other units or units systems is known.\nThe content model of gml:UnitDefinition adds three additional properties to gml:Definition, gml:quantityType, gml:quantityTypeReference and gml:catalogSymbol.  \nThe gml:catalogSymbol property optionally gives the short symbol used for this unit. This element is usually used when the relationship of this unit to other units or units systems is unknown.')

    
    # Attribute uuidref uses Python identifier uuidref
    __uuidref = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'uuidref'), 'uuidref', '__httpwww_isotc211_org2005gco_UomScale_PropertyType_uuidref', pyxb.binding.datatypes.string)
    __uuidref._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 30, 2)
    __uuidref._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 30, 2)
    
    uuidref = property(__uuidref.value, __uuidref.set, None, None)

    
    # Attribute {http://www.isotc211.org/2005/gco}nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gco, 'nilReason'), 'nilReason', '__httpwww_isotc211_org2005gco_UomScale_PropertyType_httpwww_isotc211_org2005gconilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 33, 1)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 240, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}type uses Python identifier type
    __type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'type'), 'type', '__httpwww_isotc211_org2005gco_UomScale_PropertyType_httpwww_w3_org1999xlinktype', _ImportedBinding_bindings_v1411_write__xlink.typeType, fixed=True, unicode_default='simple')
    __type._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 29, 1)
    __type._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 112, 2)
    
    type = property(__type.value, __type.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}href uses Python identifier href
    __href = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'href'), 'href', '__httpwww_isotc211_org2005gco_UomScale_PropertyType_httpwww_w3_org1999xlinkhref', _ImportedBinding_bindings_v1411_write__xlink.hrefType)
    __href._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 42, 1)
    __href._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 113, 2)
    
    href = property(__href.value, __href.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}role uses Python identifier role
    __role = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'role'), 'role', '__httpwww_isotc211_org2005gco_UomScale_PropertyType_httpwww_w3_org1999xlinkrole', _ImportedBinding_bindings_v1411_write__xlink.roleType)
    __role._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 48, 1)
    __role._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 114, 2)
    
    role = property(__role.value, __role.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}arcrole uses Python identifier arcrole
    __arcrole = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'arcrole'), 'arcrole', '__httpwww_isotc211_org2005gco_UomScale_PropertyType_httpwww_w3_org1999xlinkarcrole', _ImportedBinding_bindings_v1411_write__xlink.arcroleType)
    __arcrole._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 56, 1)
    __arcrole._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 115, 2)
    
    arcrole = property(__arcrole.value, __arcrole.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}title uses Python identifier title
    __title = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'title'), 'title', '__httpwww_isotc211_org2005gco_UomScale_PropertyType_httpwww_w3_org1999xlinktitle', _ImportedBinding_bindings_v1411_write__xlink.titleAttrType)
    __title._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 64, 1)
    __title._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 116, 2)
    
    title = property(__title.value, __title.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}show uses Python identifier show
    __show = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'show'), 'show', '__httpwww_isotc211_org2005gco_UomScale_PropertyType_httpwww_w3_org1999xlinkshow', _ImportedBinding_bindings_v1411_write__xlink.showType)
    __show._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 70, 1)
    __show._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 117, 2)
    
    show = property(__show.value, __show.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}actuate uses Python identifier actuate
    __actuate = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'actuate'), 'actuate', '__httpwww_isotc211_org2005gco_UomScale_PropertyType_httpwww_w3_org1999xlinkactuate', _ImportedBinding_bindings_v1411_write__xlink.actuateType)
    __actuate._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 82, 1)
    __actuate._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 118, 2)
    
    actuate = property(__actuate.value, __actuate.set, None, None)

    _ElementMap.update({
        __UnitDefinition.name() : __UnitDefinition
    })
    _AttributeMap.update({
        __uuidref.name() : __uuidref,
        __nilReason.name() : __nilReason,
        __type.name() : __type,
        __href.name() : __href,
        __role.name() : __role,
        __arcrole.name() : __arcrole,
        __title.name() : __title,
        __show.name() : __show,
        __actuate.name() : __actuate
    })
_module_typeBindings.UomScale_PropertyType = UomScale_PropertyType
_Namespace_gco.addCategoryObject('typeBinding', 'UomScale_PropertyType', UomScale_PropertyType)


# Complex type {http://www.isotc211.org/2005/gco}UnitOfMeasure_PropertyType with content type ELEMENT_ONLY
class UnitOfMeasure_PropertyType (pyxb.binding.basis.complexTypeDefinition):
    """Complex type {http://www.isotc211.org/2005/gco}UnitOfMeasure_PropertyType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gco, 'UnitOfMeasure_PropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 245, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.opengis.net/gml/3.2}UnitDefinition uses Python identifier UnitDefinition
    __UnitDefinition = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'UnitDefinition'), 'UnitDefinition', '__httpwww_isotc211_org2005gco_UnitOfMeasure_PropertyType_httpwww_opengis_netgml3_2UnitDefinition', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/units.xsd', 30, 1), )

    
    UnitDefinition = property(__UnitDefinition.value, __UnitDefinition.set, None, 'A gml:UnitDefinition is a general definition of a unit of measure. This generic element is used only for units for which no relationship with other units or units systems is known.\nThe content model of gml:UnitDefinition adds three additional properties to gml:Definition, gml:quantityType, gml:quantityTypeReference and gml:catalogSymbol.  \nThe gml:catalogSymbol property optionally gives the short symbol used for this unit. This element is usually used when the relationship of this unit to other units or units systems is unknown.')

    
    # Attribute uuidref uses Python identifier uuidref
    __uuidref = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'uuidref'), 'uuidref', '__httpwww_isotc211_org2005gco_UnitOfMeasure_PropertyType_uuidref', pyxb.binding.datatypes.string)
    __uuidref._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 30, 2)
    __uuidref._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 30, 2)
    
    uuidref = property(__uuidref.value, __uuidref.set, None, None)

    
    # Attribute {http://www.isotc211.org/2005/gco}nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gco, 'nilReason'), 'nilReason', '__httpwww_isotc211_org2005gco_UnitOfMeasure_PropertyType_httpwww_isotc211_org2005gconilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 33, 1)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 250, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}type uses Python identifier type
    __type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'type'), 'type', '__httpwww_isotc211_org2005gco_UnitOfMeasure_PropertyType_httpwww_w3_org1999xlinktype', _ImportedBinding_bindings_v1411_write__xlink.typeType, fixed=True, unicode_default='simple')
    __type._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 29, 1)
    __type._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 112, 2)
    
    type = property(__type.value, __type.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}href uses Python identifier href
    __href = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'href'), 'href', '__httpwww_isotc211_org2005gco_UnitOfMeasure_PropertyType_httpwww_w3_org1999xlinkhref', _ImportedBinding_bindings_v1411_write__xlink.hrefType)
    __href._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 42, 1)
    __href._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 113, 2)
    
    href = property(__href.value, __href.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}role uses Python identifier role
    __role = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'role'), 'role', '__httpwww_isotc211_org2005gco_UnitOfMeasure_PropertyType_httpwww_w3_org1999xlinkrole', _ImportedBinding_bindings_v1411_write__xlink.roleType)
    __role._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 48, 1)
    __role._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 114, 2)
    
    role = property(__role.value, __role.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}arcrole uses Python identifier arcrole
    __arcrole = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'arcrole'), 'arcrole', '__httpwww_isotc211_org2005gco_UnitOfMeasure_PropertyType_httpwww_w3_org1999xlinkarcrole', _ImportedBinding_bindings_v1411_write__xlink.arcroleType)
    __arcrole._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 56, 1)
    __arcrole._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 115, 2)
    
    arcrole = property(__arcrole.value, __arcrole.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}title uses Python identifier title
    __title = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'title'), 'title', '__httpwww_isotc211_org2005gco_UnitOfMeasure_PropertyType_httpwww_w3_org1999xlinktitle', _ImportedBinding_bindings_v1411_write__xlink.titleAttrType)
    __title._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 64, 1)
    __title._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 116, 2)
    
    title = property(__title.value, __title.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}show uses Python identifier show
    __show = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'show'), 'show', '__httpwww_isotc211_org2005gco_UnitOfMeasure_PropertyType_httpwww_w3_org1999xlinkshow', _ImportedBinding_bindings_v1411_write__xlink.showType)
    __show._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 70, 1)
    __show._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 117, 2)
    
    show = property(__show.value, __show.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}actuate uses Python identifier actuate
    __actuate = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'actuate'), 'actuate', '__httpwww_isotc211_org2005gco_UnitOfMeasure_PropertyType_httpwww_w3_org1999xlinkactuate', _ImportedBinding_bindings_v1411_write__xlink.actuateType)
    __actuate._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 82, 1)
    __actuate._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 118, 2)
    
    actuate = property(__actuate.value, __actuate.set, None, None)

    _ElementMap.update({
        __UnitDefinition.name() : __UnitDefinition
    })
    _AttributeMap.update({
        __uuidref.name() : __uuidref,
        __nilReason.name() : __nilReason,
        __type.name() : __type,
        __href.name() : __href,
        __role.name() : __role,
        __arcrole.name() : __arcrole,
        __title.name() : __title,
        __show.name() : __show,
        __actuate.name() : __actuate
    })
_module_typeBindings.UnitOfMeasure_PropertyType = UnitOfMeasure_PropertyType
_Namespace_gco.addCategoryObject('typeBinding', 'UnitOfMeasure_PropertyType', UnitOfMeasure_PropertyType)


# Complex type {http://www.isotc211.org/2005/gco}UomArea_PropertyType with content type ELEMENT_ONLY
class UomArea_PropertyType (pyxb.binding.basis.complexTypeDefinition):
    """Complex type {http://www.isotc211.org/2005/gco}UomArea_PropertyType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gco, 'UomArea_PropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 255, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.opengis.net/gml/3.2}UnitDefinition uses Python identifier UnitDefinition
    __UnitDefinition = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'UnitDefinition'), 'UnitDefinition', '__httpwww_isotc211_org2005gco_UomArea_PropertyType_httpwww_opengis_netgml3_2UnitDefinition', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/units.xsd', 30, 1), )

    
    UnitDefinition = property(__UnitDefinition.value, __UnitDefinition.set, None, 'A gml:UnitDefinition is a general definition of a unit of measure. This generic element is used only for units for which no relationship with other units or units systems is known.\nThe content model of gml:UnitDefinition adds three additional properties to gml:Definition, gml:quantityType, gml:quantityTypeReference and gml:catalogSymbol.  \nThe gml:catalogSymbol property optionally gives the short symbol used for this unit. This element is usually used when the relationship of this unit to other units or units systems is unknown.')

    
    # Attribute uuidref uses Python identifier uuidref
    __uuidref = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'uuidref'), 'uuidref', '__httpwww_isotc211_org2005gco_UomArea_PropertyType_uuidref', pyxb.binding.datatypes.string)
    __uuidref._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 30, 2)
    __uuidref._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 30, 2)
    
    uuidref = property(__uuidref.value, __uuidref.set, None, None)

    
    # Attribute {http://www.isotc211.org/2005/gco}nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gco, 'nilReason'), 'nilReason', '__httpwww_isotc211_org2005gco_UomArea_PropertyType_httpwww_isotc211_org2005gconilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 33, 1)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 260, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}type uses Python identifier type
    __type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'type'), 'type', '__httpwww_isotc211_org2005gco_UomArea_PropertyType_httpwww_w3_org1999xlinktype', _ImportedBinding_bindings_v1411_write__xlink.typeType, fixed=True, unicode_default='simple')
    __type._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 29, 1)
    __type._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 112, 2)
    
    type = property(__type.value, __type.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}href uses Python identifier href
    __href = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'href'), 'href', '__httpwww_isotc211_org2005gco_UomArea_PropertyType_httpwww_w3_org1999xlinkhref', _ImportedBinding_bindings_v1411_write__xlink.hrefType)
    __href._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 42, 1)
    __href._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 113, 2)
    
    href = property(__href.value, __href.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}role uses Python identifier role
    __role = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'role'), 'role', '__httpwww_isotc211_org2005gco_UomArea_PropertyType_httpwww_w3_org1999xlinkrole', _ImportedBinding_bindings_v1411_write__xlink.roleType)
    __role._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 48, 1)
    __role._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 114, 2)
    
    role = property(__role.value, __role.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}arcrole uses Python identifier arcrole
    __arcrole = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'arcrole'), 'arcrole', '__httpwww_isotc211_org2005gco_UomArea_PropertyType_httpwww_w3_org1999xlinkarcrole', _ImportedBinding_bindings_v1411_write__xlink.arcroleType)
    __arcrole._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 56, 1)
    __arcrole._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 115, 2)
    
    arcrole = property(__arcrole.value, __arcrole.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}title uses Python identifier title
    __title = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'title'), 'title', '__httpwww_isotc211_org2005gco_UomArea_PropertyType_httpwww_w3_org1999xlinktitle', _ImportedBinding_bindings_v1411_write__xlink.titleAttrType)
    __title._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 64, 1)
    __title._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 116, 2)
    
    title = property(__title.value, __title.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}show uses Python identifier show
    __show = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'show'), 'show', '__httpwww_isotc211_org2005gco_UomArea_PropertyType_httpwww_w3_org1999xlinkshow', _ImportedBinding_bindings_v1411_write__xlink.showType)
    __show._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 70, 1)
    __show._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 117, 2)
    
    show = property(__show.value, __show.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}actuate uses Python identifier actuate
    __actuate = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'actuate'), 'actuate', '__httpwww_isotc211_org2005gco_UomArea_PropertyType_httpwww_w3_org1999xlinkactuate', _ImportedBinding_bindings_v1411_write__xlink.actuateType)
    __actuate._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 82, 1)
    __actuate._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 118, 2)
    
    actuate = property(__actuate.value, __actuate.set, None, None)

    _ElementMap.update({
        __UnitDefinition.name() : __UnitDefinition
    })
    _AttributeMap.update({
        __uuidref.name() : __uuidref,
        __nilReason.name() : __nilReason,
        __type.name() : __type,
        __href.name() : __href,
        __role.name() : __role,
        __arcrole.name() : __arcrole,
        __title.name() : __title,
        __show.name() : __show,
        __actuate.name() : __actuate
    })
_module_typeBindings.UomArea_PropertyType = UomArea_PropertyType
_Namespace_gco.addCategoryObject('typeBinding', 'UomArea_PropertyType', UomArea_PropertyType)


# Complex type {http://www.isotc211.org/2005/gco}UomVelocity_PropertyType with content type ELEMENT_ONLY
class UomVelocity_PropertyType (pyxb.binding.basis.complexTypeDefinition):
    """Complex type {http://www.isotc211.org/2005/gco}UomVelocity_PropertyType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gco, 'UomVelocity_PropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 265, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.opengis.net/gml/3.2}UnitDefinition uses Python identifier UnitDefinition
    __UnitDefinition = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'UnitDefinition'), 'UnitDefinition', '__httpwww_isotc211_org2005gco_UomVelocity_PropertyType_httpwww_opengis_netgml3_2UnitDefinition', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/units.xsd', 30, 1), )

    
    UnitDefinition = property(__UnitDefinition.value, __UnitDefinition.set, None, 'A gml:UnitDefinition is a general definition of a unit of measure. This generic element is used only for units for which no relationship with other units or units systems is known.\nThe content model of gml:UnitDefinition adds three additional properties to gml:Definition, gml:quantityType, gml:quantityTypeReference and gml:catalogSymbol.  \nThe gml:catalogSymbol property optionally gives the short symbol used for this unit. This element is usually used when the relationship of this unit to other units or units systems is unknown.')

    
    # Attribute uuidref uses Python identifier uuidref
    __uuidref = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'uuidref'), 'uuidref', '__httpwww_isotc211_org2005gco_UomVelocity_PropertyType_uuidref', pyxb.binding.datatypes.string)
    __uuidref._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 30, 2)
    __uuidref._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 30, 2)
    
    uuidref = property(__uuidref.value, __uuidref.set, None, None)

    
    # Attribute {http://www.isotc211.org/2005/gco}nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gco, 'nilReason'), 'nilReason', '__httpwww_isotc211_org2005gco_UomVelocity_PropertyType_httpwww_isotc211_org2005gconilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 33, 1)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 270, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}type uses Python identifier type
    __type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'type'), 'type', '__httpwww_isotc211_org2005gco_UomVelocity_PropertyType_httpwww_w3_org1999xlinktype', _ImportedBinding_bindings_v1411_write__xlink.typeType, fixed=True, unicode_default='simple')
    __type._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 29, 1)
    __type._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 112, 2)
    
    type = property(__type.value, __type.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}href uses Python identifier href
    __href = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'href'), 'href', '__httpwww_isotc211_org2005gco_UomVelocity_PropertyType_httpwww_w3_org1999xlinkhref', _ImportedBinding_bindings_v1411_write__xlink.hrefType)
    __href._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 42, 1)
    __href._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 113, 2)
    
    href = property(__href.value, __href.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}role uses Python identifier role
    __role = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'role'), 'role', '__httpwww_isotc211_org2005gco_UomVelocity_PropertyType_httpwww_w3_org1999xlinkrole', _ImportedBinding_bindings_v1411_write__xlink.roleType)
    __role._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 48, 1)
    __role._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 114, 2)
    
    role = property(__role.value, __role.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}arcrole uses Python identifier arcrole
    __arcrole = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'arcrole'), 'arcrole', '__httpwww_isotc211_org2005gco_UomVelocity_PropertyType_httpwww_w3_org1999xlinkarcrole', _ImportedBinding_bindings_v1411_write__xlink.arcroleType)
    __arcrole._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 56, 1)
    __arcrole._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 115, 2)
    
    arcrole = property(__arcrole.value, __arcrole.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}title uses Python identifier title
    __title = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'title'), 'title', '__httpwww_isotc211_org2005gco_UomVelocity_PropertyType_httpwww_w3_org1999xlinktitle', _ImportedBinding_bindings_v1411_write__xlink.titleAttrType)
    __title._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 64, 1)
    __title._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 116, 2)
    
    title = property(__title.value, __title.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}show uses Python identifier show
    __show = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'show'), 'show', '__httpwww_isotc211_org2005gco_UomVelocity_PropertyType_httpwww_w3_org1999xlinkshow', _ImportedBinding_bindings_v1411_write__xlink.showType)
    __show._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 70, 1)
    __show._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 117, 2)
    
    show = property(__show.value, __show.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}actuate uses Python identifier actuate
    __actuate = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'actuate'), 'actuate', '__httpwww_isotc211_org2005gco_UomVelocity_PropertyType_httpwww_w3_org1999xlinkactuate', _ImportedBinding_bindings_v1411_write__xlink.actuateType)
    __actuate._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 82, 1)
    __actuate._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 118, 2)
    
    actuate = property(__actuate.value, __actuate.set, None, None)

    _ElementMap.update({
        __UnitDefinition.name() : __UnitDefinition
    })
    _AttributeMap.update({
        __uuidref.name() : __uuidref,
        __nilReason.name() : __nilReason,
        __type.name() : __type,
        __href.name() : __href,
        __role.name() : __role,
        __arcrole.name() : __arcrole,
        __title.name() : __title,
        __show.name() : __show,
        __actuate.name() : __actuate
    })
_module_typeBindings.UomVelocity_PropertyType = UomVelocity_PropertyType
_Namespace_gco.addCategoryObject('typeBinding', 'UomVelocity_PropertyType', UomVelocity_PropertyType)


# Complex type {http://www.isotc211.org/2005/gco}UomTime_PropertyType with content type ELEMENT_ONLY
class UomTime_PropertyType (pyxb.binding.basis.complexTypeDefinition):
    """Complex type {http://www.isotc211.org/2005/gco}UomTime_PropertyType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gco, 'UomTime_PropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 275, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.opengis.net/gml/3.2}UnitDefinition uses Python identifier UnitDefinition
    __UnitDefinition = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'UnitDefinition'), 'UnitDefinition', '__httpwww_isotc211_org2005gco_UomTime_PropertyType_httpwww_opengis_netgml3_2UnitDefinition', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/units.xsd', 30, 1), )

    
    UnitDefinition = property(__UnitDefinition.value, __UnitDefinition.set, None, 'A gml:UnitDefinition is a general definition of a unit of measure. This generic element is used only for units for which no relationship with other units or units systems is known.\nThe content model of gml:UnitDefinition adds three additional properties to gml:Definition, gml:quantityType, gml:quantityTypeReference and gml:catalogSymbol.  \nThe gml:catalogSymbol property optionally gives the short symbol used for this unit. This element is usually used when the relationship of this unit to other units or units systems is unknown.')

    
    # Attribute uuidref uses Python identifier uuidref
    __uuidref = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'uuidref'), 'uuidref', '__httpwww_isotc211_org2005gco_UomTime_PropertyType_uuidref', pyxb.binding.datatypes.string)
    __uuidref._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 30, 2)
    __uuidref._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 30, 2)
    
    uuidref = property(__uuidref.value, __uuidref.set, None, None)

    
    # Attribute {http://www.isotc211.org/2005/gco}nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gco, 'nilReason'), 'nilReason', '__httpwww_isotc211_org2005gco_UomTime_PropertyType_httpwww_isotc211_org2005gconilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 33, 1)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 280, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}type uses Python identifier type
    __type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'type'), 'type', '__httpwww_isotc211_org2005gco_UomTime_PropertyType_httpwww_w3_org1999xlinktype', _ImportedBinding_bindings_v1411_write__xlink.typeType, fixed=True, unicode_default='simple')
    __type._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 29, 1)
    __type._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 112, 2)
    
    type = property(__type.value, __type.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}href uses Python identifier href
    __href = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'href'), 'href', '__httpwww_isotc211_org2005gco_UomTime_PropertyType_httpwww_w3_org1999xlinkhref', _ImportedBinding_bindings_v1411_write__xlink.hrefType)
    __href._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 42, 1)
    __href._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 113, 2)
    
    href = property(__href.value, __href.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}role uses Python identifier role
    __role = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'role'), 'role', '__httpwww_isotc211_org2005gco_UomTime_PropertyType_httpwww_w3_org1999xlinkrole', _ImportedBinding_bindings_v1411_write__xlink.roleType)
    __role._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 48, 1)
    __role._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 114, 2)
    
    role = property(__role.value, __role.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}arcrole uses Python identifier arcrole
    __arcrole = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'arcrole'), 'arcrole', '__httpwww_isotc211_org2005gco_UomTime_PropertyType_httpwww_w3_org1999xlinkarcrole', _ImportedBinding_bindings_v1411_write__xlink.arcroleType)
    __arcrole._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 56, 1)
    __arcrole._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 115, 2)
    
    arcrole = property(__arcrole.value, __arcrole.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}title uses Python identifier title
    __title = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'title'), 'title', '__httpwww_isotc211_org2005gco_UomTime_PropertyType_httpwww_w3_org1999xlinktitle', _ImportedBinding_bindings_v1411_write__xlink.titleAttrType)
    __title._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 64, 1)
    __title._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 116, 2)
    
    title = property(__title.value, __title.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}show uses Python identifier show
    __show = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'show'), 'show', '__httpwww_isotc211_org2005gco_UomTime_PropertyType_httpwww_w3_org1999xlinkshow', _ImportedBinding_bindings_v1411_write__xlink.showType)
    __show._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 70, 1)
    __show._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 117, 2)
    
    show = property(__show.value, __show.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}actuate uses Python identifier actuate
    __actuate = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'actuate'), 'actuate', '__httpwww_isotc211_org2005gco_UomTime_PropertyType_httpwww_w3_org1999xlinkactuate', _ImportedBinding_bindings_v1411_write__xlink.actuateType)
    __actuate._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 82, 1)
    __actuate._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 118, 2)
    
    actuate = property(__actuate.value, __actuate.set, None, None)

    _ElementMap.update({
        __UnitDefinition.name() : __UnitDefinition
    })
    _AttributeMap.update({
        __uuidref.name() : __uuidref,
        __nilReason.name() : __nilReason,
        __type.name() : __type,
        __href.name() : __href,
        __role.name() : __role,
        __arcrole.name() : __arcrole,
        __title.name() : __title,
        __show.name() : __show,
        __actuate.name() : __actuate
    })
_module_typeBindings.UomTime_PropertyType = UomTime_PropertyType
_Namespace_gco.addCategoryObject('typeBinding', 'UomTime_PropertyType', UomTime_PropertyType)


# Complex type {http://www.isotc211.org/2005/gco}UomVolume_PropertyType with content type ELEMENT_ONLY
class UomVolume_PropertyType (pyxb.binding.basis.complexTypeDefinition):
    """Complex type {http://www.isotc211.org/2005/gco}UomVolume_PropertyType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gco, 'UomVolume_PropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 285, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.opengis.net/gml/3.2}UnitDefinition uses Python identifier UnitDefinition
    __UnitDefinition = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'UnitDefinition'), 'UnitDefinition', '__httpwww_isotc211_org2005gco_UomVolume_PropertyType_httpwww_opengis_netgml3_2UnitDefinition', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/units.xsd', 30, 1), )

    
    UnitDefinition = property(__UnitDefinition.value, __UnitDefinition.set, None, 'A gml:UnitDefinition is a general definition of a unit of measure. This generic element is used only for units for which no relationship with other units or units systems is known.\nThe content model of gml:UnitDefinition adds three additional properties to gml:Definition, gml:quantityType, gml:quantityTypeReference and gml:catalogSymbol.  \nThe gml:catalogSymbol property optionally gives the short symbol used for this unit. This element is usually used when the relationship of this unit to other units or units systems is unknown.')

    
    # Attribute uuidref uses Python identifier uuidref
    __uuidref = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'uuidref'), 'uuidref', '__httpwww_isotc211_org2005gco_UomVolume_PropertyType_uuidref', pyxb.binding.datatypes.string)
    __uuidref._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 30, 2)
    __uuidref._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 30, 2)
    
    uuidref = property(__uuidref.value, __uuidref.set, None, None)

    
    # Attribute {http://www.isotc211.org/2005/gco}nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gco, 'nilReason'), 'nilReason', '__httpwww_isotc211_org2005gco_UomVolume_PropertyType_httpwww_isotc211_org2005gconilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 33, 1)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 290, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}type uses Python identifier type
    __type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'type'), 'type', '__httpwww_isotc211_org2005gco_UomVolume_PropertyType_httpwww_w3_org1999xlinktype', _ImportedBinding_bindings_v1411_write__xlink.typeType, fixed=True, unicode_default='simple')
    __type._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 29, 1)
    __type._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 112, 2)
    
    type = property(__type.value, __type.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}href uses Python identifier href
    __href = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'href'), 'href', '__httpwww_isotc211_org2005gco_UomVolume_PropertyType_httpwww_w3_org1999xlinkhref', _ImportedBinding_bindings_v1411_write__xlink.hrefType)
    __href._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 42, 1)
    __href._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 113, 2)
    
    href = property(__href.value, __href.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}role uses Python identifier role
    __role = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'role'), 'role', '__httpwww_isotc211_org2005gco_UomVolume_PropertyType_httpwww_w3_org1999xlinkrole', _ImportedBinding_bindings_v1411_write__xlink.roleType)
    __role._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 48, 1)
    __role._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 114, 2)
    
    role = property(__role.value, __role.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}arcrole uses Python identifier arcrole
    __arcrole = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'arcrole'), 'arcrole', '__httpwww_isotc211_org2005gco_UomVolume_PropertyType_httpwww_w3_org1999xlinkarcrole', _ImportedBinding_bindings_v1411_write__xlink.arcroleType)
    __arcrole._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 56, 1)
    __arcrole._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 115, 2)
    
    arcrole = property(__arcrole.value, __arcrole.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}title uses Python identifier title
    __title = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'title'), 'title', '__httpwww_isotc211_org2005gco_UomVolume_PropertyType_httpwww_w3_org1999xlinktitle', _ImportedBinding_bindings_v1411_write__xlink.titleAttrType)
    __title._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 64, 1)
    __title._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 116, 2)
    
    title = property(__title.value, __title.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}show uses Python identifier show
    __show = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'show'), 'show', '__httpwww_isotc211_org2005gco_UomVolume_PropertyType_httpwww_w3_org1999xlinkshow', _ImportedBinding_bindings_v1411_write__xlink.showType)
    __show._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 70, 1)
    __show._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 117, 2)
    
    show = property(__show.value, __show.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}actuate uses Python identifier actuate
    __actuate = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'actuate'), 'actuate', '__httpwww_isotc211_org2005gco_UomVolume_PropertyType_httpwww_w3_org1999xlinkactuate', _ImportedBinding_bindings_v1411_write__xlink.actuateType)
    __actuate._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 82, 1)
    __actuate._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 118, 2)
    
    actuate = property(__actuate.value, __actuate.set, None, None)

    _ElementMap.update({
        __UnitDefinition.name() : __UnitDefinition
    })
    _AttributeMap.update({
        __uuidref.name() : __uuidref,
        __nilReason.name() : __nilReason,
        __type.name() : __type,
        __href.name() : __href,
        __role.name() : __role,
        __arcrole.name() : __arcrole,
        __title.name() : __title,
        __show.name() : __show,
        __actuate.name() : __actuate
    })
_module_typeBindings.UomVolume_PropertyType = UomVolume_PropertyType
_Namespace_gco.addCategoryObject('typeBinding', 'UomVolume_PropertyType', UomVolume_PropertyType)


# Complex type {http://www.isotc211.org/2005/gco}DateTime_PropertyType with content type ELEMENT_ONLY
class DateTime_PropertyType (pyxb.binding.basis.complexTypeDefinition):
    """Complex type {http://www.isotc211.org/2005/gco}DateTime_PropertyType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gco, 'DateTime_PropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 297, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.isotc211.org/2005/gco}DateTime uses Python identifier DateTime
    __DateTime = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gco, 'DateTime'), 'DateTime', '__httpwww_isotc211_org2005gco_DateTime_PropertyType_httpwww_isotc211_org2005gcoDateTime', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 295, 1), )

    
    DateTime = property(__DateTime.value, __DateTime.set, None, None)

    
    # Attribute {http://www.isotc211.org/2005/gco}nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gco, 'nilReason'), 'nilReason', '__httpwww_isotc211_org2005gco_DateTime_PropertyType_httpwww_isotc211_org2005gconilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 33, 1)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 301, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    _ElementMap.update({
        __DateTime.name() : __DateTime
    })
    _AttributeMap.update({
        __nilReason.name() : __nilReason
    })
_module_typeBindings.DateTime_PropertyType = DateTime_PropertyType
_Namespace_gco.addCategoryObject('typeBinding', 'DateTime_PropertyType', DateTime_PropertyType)


# Complex type {http://www.isotc211.org/2005/gco}Date_PropertyType with content type ELEMENT_ONLY
class Date_PropertyType (pyxb.binding.basis.complexTypeDefinition):
    """Complex type {http://www.isotc211.org/2005/gco}Date_PropertyType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gco, 'Date_PropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 310, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.isotc211.org/2005/gco}DateTime uses Python identifier DateTime
    __DateTime = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gco, 'DateTime'), 'DateTime', '__httpwww_isotc211_org2005gco_Date_PropertyType_httpwww_isotc211_org2005gcoDateTime', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 295, 1), )

    
    DateTime = property(__DateTime.value, __DateTime.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gco}Date uses Python identifier Date
    __Date = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gco, 'Date'), 'Date', '__httpwww_isotc211_org2005gco_Date_PropertyType_httpwww_isotc211_org2005gcoDate', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 308, 1), )

    
    Date = property(__Date.value, __Date.set, None, None)

    
    # Attribute {http://www.isotc211.org/2005/gco}nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gco, 'nilReason'), 'nilReason', '__httpwww_isotc211_org2005gco_Date_PropertyType_httpwww_isotc211_org2005gconilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 33, 1)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 315, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    _ElementMap.update({
        __DateTime.name() : __DateTime,
        __Date.name() : __Date
    })
    _AttributeMap.update({
        __nilReason.name() : __nilReason
    })
_module_typeBindings.Date_PropertyType = Date_PropertyType
_Namespace_gco.addCategoryObject('typeBinding', 'Date_PropertyType', Date_PropertyType)


# Complex type {http://www.isotc211.org/2005/gco}Number_PropertyType with content type ELEMENT_ONLY
class Number_PropertyType (pyxb.binding.basis.complexTypeDefinition):
    """Complex type {http://www.isotc211.org/2005/gco}Number_PropertyType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gco, 'Number_PropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 320, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.isotc211.org/2005/gco}Decimal uses Python identifier Decimal
    __Decimal = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gco, 'Decimal'), 'Decimal', '__httpwww_isotc211_org2005gco_Number_PropertyType_httpwww_isotc211_org2005gcoDecimal', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 330, 1), )

    
    Decimal = property(__Decimal.value, __Decimal.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gco}Real uses Python identifier Real
    __Real = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gco, 'Real'), 'Real', '__httpwww_isotc211_org2005gco_Number_PropertyType_httpwww_isotc211_org2005gcoReal', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 340, 1), )

    
    Real = property(__Real.value, __Real.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gco}Integer uses Python identifier Integer
    __Integer = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gco, 'Integer'), 'Integer', '__httpwww_isotc211_org2005gco_Number_PropertyType_httpwww_isotc211_org2005gcoInteger', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 350, 1), )

    
    Integer = property(__Integer.value, __Integer.set, None, None)

    
    # Attribute {http://www.isotc211.org/2005/gco}nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gco, 'nilReason'), 'nilReason', '__httpwww_isotc211_org2005gco_Number_PropertyType_httpwww_isotc211_org2005gconilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 33, 1)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 326, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    _ElementMap.update({
        __Decimal.name() : __Decimal,
        __Real.name() : __Real,
        __Integer.name() : __Integer
    })
    _AttributeMap.update({
        __nilReason.name() : __nilReason
    })
_module_typeBindings.Number_PropertyType = Number_PropertyType
_Namespace_gco.addCategoryObject('typeBinding', 'Number_PropertyType', Number_PropertyType)


# Complex type {http://www.isotc211.org/2005/gco}Decimal_PropertyType with content type ELEMENT_ONLY
class Decimal_PropertyType (pyxb.binding.basis.complexTypeDefinition):
    """Complex type {http://www.isotc211.org/2005/gco}Decimal_PropertyType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gco, 'Decimal_PropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 332, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.isotc211.org/2005/gco}Decimal uses Python identifier Decimal
    __Decimal = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gco, 'Decimal'), 'Decimal', '__httpwww_isotc211_org2005gco_Decimal_PropertyType_httpwww_isotc211_org2005gcoDecimal', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 330, 1), )

    
    Decimal = property(__Decimal.value, __Decimal.set, None, None)

    
    # Attribute {http://www.isotc211.org/2005/gco}nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gco, 'nilReason'), 'nilReason', '__httpwww_isotc211_org2005gco_Decimal_PropertyType_httpwww_isotc211_org2005gconilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 33, 1)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 336, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    _ElementMap.update({
        __Decimal.name() : __Decimal
    })
    _AttributeMap.update({
        __nilReason.name() : __nilReason
    })
_module_typeBindings.Decimal_PropertyType = Decimal_PropertyType
_Namespace_gco.addCategoryObject('typeBinding', 'Decimal_PropertyType', Decimal_PropertyType)


# Complex type {http://www.isotc211.org/2005/gco}Real_PropertyType with content type ELEMENT_ONLY
class Real_PropertyType (pyxb.binding.basis.complexTypeDefinition):
    """Complex type {http://www.isotc211.org/2005/gco}Real_PropertyType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gco, 'Real_PropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 342, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.isotc211.org/2005/gco}Real uses Python identifier Real
    __Real = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gco, 'Real'), 'Real', '__httpwww_isotc211_org2005gco_Real_PropertyType_httpwww_isotc211_org2005gcoReal', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 340, 1), )

    
    Real = property(__Real.value, __Real.set, None, None)

    
    # Attribute {http://www.isotc211.org/2005/gco}nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gco, 'nilReason'), 'nilReason', '__httpwww_isotc211_org2005gco_Real_PropertyType_httpwww_isotc211_org2005gconilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 33, 1)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 346, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    _ElementMap.update({
        __Real.name() : __Real
    })
    _AttributeMap.update({
        __nilReason.name() : __nilReason
    })
_module_typeBindings.Real_PropertyType = Real_PropertyType
_Namespace_gco.addCategoryObject('typeBinding', 'Real_PropertyType', Real_PropertyType)


# Complex type {http://www.isotc211.org/2005/gco}Integer_PropertyType with content type ELEMENT_ONLY
class Integer_PropertyType (pyxb.binding.basis.complexTypeDefinition):
    """Complex type {http://www.isotc211.org/2005/gco}Integer_PropertyType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gco, 'Integer_PropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 352, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.isotc211.org/2005/gco}Integer uses Python identifier Integer
    __Integer = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gco, 'Integer'), 'Integer', '__httpwww_isotc211_org2005gco_Integer_PropertyType_httpwww_isotc211_org2005gcoInteger', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 350, 1), )

    
    Integer = property(__Integer.value, __Integer.set, None, None)

    
    # Attribute {http://www.isotc211.org/2005/gco}nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gco, 'nilReason'), 'nilReason', '__httpwww_isotc211_org2005gco_Integer_PropertyType_httpwww_isotc211_org2005gconilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 33, 1)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 356, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    _ElementMap.update({
        __Integer.name() : __Integer
    })
    _AttributeMap.update({
        __nilReason.name() : __nilReason
    })
_module_typeBindings.Integer_PropertyType = Integer_PropertyType
_Namespace_gco.addCategoryObject('typeBinding', 'Integer_PropertyType', Integer_PropertyType)


# Complex type {http://www.isotc211.org/2005/gco}UnlimitedInteger_PropertyType with content type ELEMENT_ONLY
class UnlimitedInteger_PropertyType (pyxb.binding.basis.complexTypeDefinition):
    """Complex type {http://www.isotc211.org/2005/gco}UnlimitedInteger_PropertyType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gco, 'UnlimitedInteger_PropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 372, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.isotc211.org/2005/gco}UnlimitedInteger uses Python identifier UnlimitedInteger
    __UnlimitedInteger = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gco, 'UnlimitedInteger'), 'UnlimitedInteger', '__httpwww_isotc211_org2005gco_UnlimitedInteger_PropertyType_httpwww_isotc211_org2005gcoUnlimitedInteger', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 370, 1), )

    
    UnlimitedInteger = property(__UnlimitedInteger.value, __UnlimitedInteger.set, None, None)

    
    # Attribute {http://www.isotc211.org/2005/gco}nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gco, 'nilReason'), 'nilReason', '__httpwww_isotc211_org2005gco_UnlimitedInteger_PropertyType_httpwww_isotc211_org2005gconilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 33, 1)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 376, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    _ElementMap.update({
        __UnlimitedInteger.name() : __UnlimitedInteger
    })
    _AttributeMap.update({
        __nilReason.name() : __nilReason
    })
_module_typeBindings.UnlimitedInteger_PropertyType = UnlimitedInteger_PropertyType
_Namespace_gco.addCategoryObject('typeBinding', 'UnlimitedInteger_PropertyType', UnlimitedInteger_PropertyType)


# Complex type {http://www.isotc211.org/2005/gco}Record_PropertyType with content type ELEMENT_ONLY
class Record_PropertyType (pyxb.binding.basis.complexTypeDefinition):
    """Complex type {http://www.isotc211.org/2005/gco}Record_PropertyType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gco, 'Record_PropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 383, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.isotc211.org/2005/gco}Record uses Python identifier Record
    __Record = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gco, 'Record'), 'Record', '__httpwww_isotc211_org2005gco_Record_PropertyType_httpwww_isotc211_org2005gcoRecord', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 381, 1), )

    
    Record = property(__Record.value, __Record.set, None, None)

    
    # Attribute uuidref uses Python identifier uuidref
    __uuidref = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'uuidref'), 'uuidref', '__httpwww_isotc211_org2005gco_Record_PropertyType_uuidref', pyxb.binding.datatypes.string)
    __uuidref._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 30, 2)
    __uuidref._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 30, 2)
    
    uuidref = property(__uuidref.value, __uuidref.set, None, None)

    
    # Attribute {http://www.isotc211.org/2005/gco}nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gco, 'nilReason'), 'nilReason', '__httpwww_isotc211_org2005gco_Record_PropertyType_httpwww_isotc211_org2005gconilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 33, 1)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 388, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}type uses Python identifier type
    __type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'type'), 'type', '__httpwww_isotc211_org2005gco_Record_PropertyType_httpwww_w3_org1999xlinktype', _ImportedBinding_bindings_v1411_write__xlink.typeType, fixed=True, unicode_default='simple')
    __type._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 29, 1)
    __type._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 112, 2)
    
    type = property(__type.value, __type.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}href uses Python identifier href
    __href = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'href'), 'href', '__httpwww_isotc211_org2005gco_Record_PropertyType_httpwww_w3_org1999xlinkhref', _ImportedBinding_bindings_v1411_write__xlink.hrefType)
    __href._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 42, 1)
    __href._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 113, 2)
    
    href = property(__href.value, __href.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}role uses Python identifier role
    __role = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'role'), 'role', '__httpwww_isotc211_org2005gco_Record_PropertyType_httpwww_w3_org1999xlinkrole', _ImportedBinding_bindings_v1411_write__xlink.roleType)
    __role._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 48, 1)
    __role._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 114, 2)
    
    role = property(__role.value, __role.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}arcrole uses Python identifier arcrole
    __arcrole = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'arcrole'), 'arcrole', '__httpwww_isotc211_org2005gco_Record_PropertyType_httpwww_w3_org1999xlinkarcrole', _ImportedBinding_bindings_v1411_write__xlink.arcroleType)
    __arcrole._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 56, 1)
    __arcrole._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 115, 2)
    
    arcrole = property(__arcrole.value, __arcrole.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}title uses Python identifier title
    __title = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'title'), 'title', '__httpwww_isotc211_org2005gco_Record_PropertyType_httpwww_w3_org1999xlinktitle', _ImportedBinding_bindings_v1411_write__xlink.titleAttrType)
    __title._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 64, 1)
    __title._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 116, 2)
    
    title = property(__title.value, __title.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}show uses Python identifier show
    __show = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'show'), 'show', '__httpwww_isotc211_org2005gco_Record_PropertyType_httpwww_w3_org1999xlinkshow', _ImportedBinding_bindings_v1411_write__xlink.showType)
    __show._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 70, 1)
    __show._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 117, 2)
    
    show = property(__show.value, __show.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}actuate uses Python identifier actuate
    __actuate = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'actuate'), 'actuate', '__httpwww_isotc211_org2005gco_Record_PropertyType_httpwww_w3_org1999xlinkactuate', _ImportedBinding_bindings_v1411_write__xlink.actuateType)
    __actuate._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 82, 1)
    __actuate._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 118, 2)
    
    actuate = property(__actuate.value, __actuate.set, None, None)

    _ElementMap.update({
        __Record.name() : __Record
    })
    _AttributeMap.update({
        __uuidref.name() : __uuidref,
        __nilReason.name() : __nilReason,
        __type.name() : __type,
        __href.name() : __href,
        __role.name() : __role,
        __arcrole.name() : __arcrole,
        __title.name() : __title,
        __show.name() : __show,
        __actuate.name() : __actuate
    })
_module_typeBindings.Record_PropertyType = Record_PropertyType
_Namespace_gco.addCategoryObject('typeBinding', 'Record_PropertyType', Record_PropertyType)


# Complex type {http://www.isotc211.org/2005/gco}RecordType_PropertyType with content type ELEMENT_ONLY
class RecordType_PropertyType (pyxb.binding.basis.complexTypeDefinition):
    """Complex type {http://www.isotc211.org/2005/gco}RecordType_PropertyType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gco, 'RecordType_PropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 402, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.isotc211.org/2005/gco}RecordType uses Python identifier RecordType
    __RecordType = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gco, 'RecordType'), 'RecordType', '__httpwww_isotc211_org2005gco_RecordType_PropertyType_httpwww_isotc211_org2005gcoRecordType', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 400, 1), )

    
    RecordType = property(__RecordType.value, __RecordType.set, None, None)

    
    # Attribute {http://www.isotc211.org/2005/gco}nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gco, 'nilReason'), 'nilReason', '__httpwww_isotc211_org2005gco_RecordType_PropertyType_httpwww_isotc211_org2005gconilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 33, 1)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 406, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    _ElementMap.update({
        __RecordType.name() : __RecordType
    })
    _AttributeMap.update({
        __nilReason.name() : __nilReason
    })
_module_typeBindings.RecordType_PropertyType = RecordType_PropertyType
_Namespace_gco.addCategoryObject('typeBinding', 'RecordType_PropertyType', RecordType_PropertyType)


# Complex type {http://www.isotc211.org/2005/gco}Binary_PropertyType with content type ELEMENT_ONLY
class Binary_PropertyType (pyxb.binding.basis.complexTypeDefinition):
    """Complex type {http://www.isotc211.org/2005/gco}Binary_PropertyType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gco, 'Binary_PropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 422, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.isotc211.org/2005/gco}Binary uses Python identifier Binary
    __Binary = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gco, 'Binary'), 'Binary', '__httpwww_isotc211_org2005gco_Binary_PropertyType_httpwww_isotc211_org2005gcoBinary', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 420, 1), )

    
    Binary = property(__Binary.value, __Binary.set, None, None)

    
    # Attribute {http://www.isotc211.org/2005/gco}nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gco, 'nilReason'), 'nilReason', '__httpwww_isotc211_org2005gco_Binary_PropertyType_httpwww_isotc211_org2005gconilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 33, 1)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 426, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    _ElementMap.update({
        __Binary.name() : __Binary
    })
    _AttributeMap.update({
        __nilReason.name() : __nilReason
    })
_module_typeBindings.Binary_PropertyType = Binary_PropertyType
_Namespace_gco.addCategoryObject('typeBinding', 'Binary_PropertyType', Binary_PropertyType)


# Complex type {http://www.isotc211.org/2005/gco}ObjectReference_PropertyType with content type EMPTY
class ObjectReference_PropertyType (pyxb.binding.basis.complexTypeDefinition):
    """Complex type {http://www.isotc211.org/2005/gco}ObjectReference_PropertyType with content type EMPTY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_EMPTY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gco, 'ObjectReference_PropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 35, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Attribute uuidref uses Python identifier uuidref
    __uuidref = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'uuidref'), 'uuidref', '__httpwww_isotc211_org2005gco_ObjectReference_PropertyType_uuidref', pyxb.binding.datatypes.string)
    __uuidref._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 30, 2)
    __uuidref._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 30, 2)
    
    uuidref = property(__uuidref.value, __uuidref.set, None, None)

    
    # Attribute {http://www.isotc211.org/2005/gco}nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gco, 'nilReason'), 'nilReason', '__httpwww_isotc211_org2005gco_ObjectReference_PropertyType_httpwww_isotc211_org2005gconilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 33, 1)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 38, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}type uses Python identifier type
    __type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'type'), 'type', '__httpwww_isotc211_org2005gco_ObjectReference_PropertyType_httpwww_w3_org1999xlinktype', _ImportedBinding_bindings_v1411_write__xlink.typeType, fixed=True, unicode_default='simple')
    __type._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 29, 1)
    __type._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 112, 2)
    
    type = property(__type.value, __type.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}href uses Python identifier href
    __href = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'href'), 'href', '__httpwww_isotc211_org2005gco_ObjectReference_PropertyType_httpwww_w3_org1999xlinkhref', _ImportedBinding_bindings_v1411_write__xlink.hrefType)
    __href._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 42, 1)
    __href._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 113, 2)
    
    href = property(__href.value, __href.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}role uses Python identifier role
    __role = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'role'), 'role', '__httpwww_isotc211_org2005gco_ObjectReference_PropertyType_httpwww_w3_org1999xlinkrole', _ImportedBinding_bindings_v1411_write__xlink.roleType)
    __role._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 48, 1)
    __role._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 114, 2)
    
    role = property(__role.value, __role.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}arcrole uses Python identifier arcrole
    __arcrole = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'arcrole'), 'arcrole', '__httpwww_isotc211_org2005gco_ObjectReference_PropertyType_httpwww_w3_org1999xlinkarcrole', _ImportedBinding_bindings_v1411_write__xlink.arcroleType)
    __arcrole._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 56, 1)
    __arcrole._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 115, 2)
    
    arcrole = property(__arcrole.value, __arcrole.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}title uses Python identifier title
    __title = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'title'), 'title', '__httpwww_isotc211_org2005gco_ObjectReference_PropertyType_httpwww_w3_org1999xlinktitle', _ImportedBinding_bindings_v1411_write__xlink.titleAttrType)
    __title._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 64, 1)
    __title._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 116, 2)
    
    title = property(__title.value, __title.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}show uses Python identifier show
    __show = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'show'), 'show', '__httpwww_isotc211_org2005gco_ObjectReference_PropertyType_httpwww_w3_org1999xlinkshow', _ImportedBinding_bindings_v1411_write__xlink.showType)
    __show._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 70, 1)
    __show._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 117, 2)
    
    show = property(__show.value, __show.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}actuate uses Python identifier actuate
    __actuate = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'actuate'), 'actuate', '__httpwww_isotc211_org2005gco_ObjectReference_PropertyType_httpwww_w3_org1999xlinkactuate', _ImportedBinding_bindings_v1411_write__xlink.actuateType)
    __actuate._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 82, 1)
    __actuate._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 118, 2)
    
    actuate = property(__actuate.value, __actuate.set, None, None)

    _ElementMap.update({
        
    })
    _AttributeMap.update({
        __uuidref.name() : __uuidref,
        __nilReason.name() : __nilReason,
        __type.name() : __type,
        __href.name() : __href,
        __role.name() : __role,
        __arcrole.name() : __arcrole,
        __title.name() : __title,
        __show.name() : __show,
        __actuate.name() : __actuate
    })
_module_typeBindings.ObjectReference_PropertyType = ObjectReference_PropertyType
_Namespace_gco.addCategoryObject('typeBinding', 'ObjectReference_PropertyType', ObjectReference_PropertyType)


# Complex type {http://www.isotc211.org/2005/gmd}MD_ApplicationSchemaInformation_PropertyType with content type ELEMENT_ONLY
class MD_ApplicationSchemaInformation_PropertyType (pyxb.binding.basis.complexTypeDefinition):
    """Complex type {http://www.isotc211.org/2005/gmd}MD_ApplicationSchemaInformation_PropertyType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_ApplicationSchemaInformation_PropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/applicationSchema.xsd', 35, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.isotc211.org/2005/gmd}MD_ApplicationSchemaInformation uses Python identifier MD_ApplicationSchemaInformation
    __MD_ApplicationSchemaInformation = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_ApplicationSchemaInformation'), 'MD_ApplicationSchemaInformation', '__httpwww_isotc211_org2005gmd_MD_ApplicationSchemaInformation_PropertyType_httpwww_isotc211_org2005gmdMD_ApplicationSchemaInformation', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/applicationSchema.xsd', 33, 1), )

    
    MD_ApplicationSchemaInformation = property(__MD_ApplicationSchemaInformation.value, __MD_ApplicationSchemaInformation.set, None, None)

    
    # Attribute uuidref uses Python identifier uuidref
    __uuidref = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'uuidref'), 'uuidref', '__httpwww_isotc211_org2005gmd_MD_ApplicationSchemaInformation_PropertyType_uuidref', pyxb.binding.datatypes.string)
    __uuidref._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 30, 2)
    __uuidref._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 30, 2)
    
    uuidref = property(__uuidref.value, __uuidref.set, None, None)

    
    # Attribute {http://www.isotc211.org/2005/gco}nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gco, 'nilReason'), 'nilReason', '__httpwww_isotc211_org2005gmd_MD_ApplicationSchemaInformation_PropertyType_httpwww_isotc211_org2005gconilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 33, 1)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/applicationSchema.xsd', 40, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}type uses Python identifier type
    __type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'type'), 'type', '__httpwww_isotc211_org2005gmd_MD_ApplicationSchemaInformation_PropertyType_httpwww_w3_org1999xlinktype', _ImportedBinding_bindings_v1411_write__xlink.typeType, fixed=True, unicode_default='simple')
    __type._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 29, 1)
    __type._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 112, 2)
    
    type = property(__type.value, __type.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}href uses Python identifier href
    __href = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'href'), 'href', '__httpwww_isotc211_org2005gmd_MD_ApplicationSchemaInformation_PropertyType_httpwww_w3_org1999xlinkhref', _ImportedBinding_bindings_v1411_write__xlink.hrefType)
    __href._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 42, 1)
    __href._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 113, 2)
    
    href = property(__href.value, __href.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}role uses Python identifier role
    __role = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'role'), 'role', '__httpwww_isotc211_org2005gmd_MD_ApplicationSchemaInformation_PropertyType_httpwww_w3_org1999xlinkrole', _ImportedBinding_bindings_v1411_write__xlink.roleType)
    __role._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 48, 1)
    __role._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 114, 2)
    
    role = property(__role.value, __role.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}arcrole uses Python identifier arcrole
    __arcrole = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'arcrole'), 'arcrole', '__httpwww_isotc211_org2005gmd_MD_ApplicationSchemaInformation_PropertyType_httpwww_w3_org1999xlinkarcrole', _ImportedBinding_bindings_v1411_write__xlink.arcroleType)
    __arcrole._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 56, 1)
    __arcrole._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 115, 2)
    
    arcrole = property(__arcrole.value, __arcrole.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}title uses Python identifier title
    __title = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'title'), 'title', '__httpwww_isotc211_org2005gmd_MD_ApplicationSchemaInformation_PropertyType_httpwww_w3_org1999xlinktitle', _ImportedBinding_bindings_v1411_write__xlink.titleAttrType)
    __title._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 64, 1)
    __title._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 116, 2)
    
    title = property(__title.value, __title.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}show uses Python identifier show
    __show = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'show'), 'show', '__httpwww_isotc211_org2005gmd_MD_ApplicationSchemaInformation_PropertyType_httpwww_w3_org1999xlinkshow', _ImportedBinding_bindings_v1411_write__xlink.showType)
    __show._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 70, 1)
    __show._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 117, 2)
    
    show = property(__show.value, __show.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}actuate uses Python identifier actuate
    __actuate = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'actuate'), 'actuate', '__httpwww_isotc211_org2005gmd_MD_ApplicationSchemaInformation_PropertyType_httpwww_w3_org1999xlinkactuate', _ImportedBinding_bindings_v1411_write__xlink.actuateType)
    __actuate._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 82, 1)
    __actuate._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 118, 2)
    
    actuate = property(__actuate.value, __actuate.set, None, None)

    _ElementMap.update({
        __MD_ApplicationSchemaInformation.name() : __MD_ApplicationSchemaInformation
    })
    _AttributeMap.update({
        __uuidref.name() : __uuidref,
        __nilReason.name() : __nilReason,
        __type.name() : __type,
        __href.name() : __href,
        __role.name() : __role,
        __arcrole.name() : __arcrole,
        __title.name() : __title,
        __show.name() : __show,
        __actuate.name() : __actuate
    })
_module_typeBindings.MD_ApplicationSchemaInformation_PropertyType = MD_ApplicationSchemaInformation_PropertyType
_Namespace_gmd.addCategoryObject('typeBinding', 'MD_ApplicationSchemaInformation_PropertyType', MD_ApplicationSchemaInformation_PropertyType)


# Complex type {http://www.isotc211.org/2005/gmd}CI_ResponsibleParty_PropertyType with content type ELEMENT_ONLY
class CI_ResponsibleParty_PropertyType (pyxb.binding.basis.complexTypeDefinition):
    """Complex type {http://www.isotc211.org/2005/gmd}CI_ResponsibleParty_PropertyType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'CI_ResponsibleParty_PropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 33, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.isotc211.org/2005/gmd}CI_ResponsibleParty uses Python identifier CI_ResponsibleParty
    __CI_ResponsibleParty = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'CI_ResponsibleParty'), 'CI_ResponsibleParty', '__httpwww_isotc211_org2005gmd_CI_ResponsibleParty_PropertyType_httpwww_isotc211_org2005gmdCI_ResponsibleParty', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 31, 1), )

    
    CI_ResponsibleParty = property(__CI_ResponsibleParty.value, __CI_ResponsibleParty.set, None, None)

    
    # Attribute uuidref uses Python identifier uuidref
    __uuidref = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'uuidref'), 'uuidref', '__httpwww_isotc211_org2005gmd_CI_ResponsibleParty_PropertyType_uuidref', pyxb.binding.datatypes.string)
    __uuidref._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 30, 2)
    __uuidref._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 30, 2)
    
    uuidref = property(__uuidref.value, __uuidref.set, None, None)

    
    # Attribute {http://www.isotc211.org/2005/gco}nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gco, 'nilReason'), 'nilReason', '__httpwww_isotc211_org2005gmd_CI_ResponsibleParty_PropertyType_httpwww_isotc211_org2005gconilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 33, 1)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 38, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}type uses Python identifier type
    __type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'type'), 'type', '__httpwww_isotc211_org2005gmd_CI_ResponsibleParty_PropertyType_httpwww_w3_org1999xlinktype', _ImportedBinding_bindings_v1411_write__xlink.typeType, fixed=True, unicode_default='simple')
    __type._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 29, 1)
    __type._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 112, 2)
    
    type = property(__type.value, __type.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}href uses Python identifier href
    __href = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'href'), 'href', '__httpwww_isotc211_org2005gmd_CI_ResponsibleParty_PropertyType_httpwww_w3_org1999xlinkhref', _ImportedBinding_bindings_v1411_write__xlink.hrefType)
    __href._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 42, 1)
    __href._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 113, 2)
    
    href = property(__href.value, __href.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}role uses Python identifier role
    __role = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'role'), 'role', '__httpwww_isotc211_org2005gmd_CI_ResponsibleParty_PropertyType_httpwww_w3_org1999xlinkrole', _ImportedBinding_bindings_v1411_write__xlink.roleType)
    __role._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 48, 1)
    __role._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 114, 2)
    
    role = property(__role.value, __role.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}arcrole uses Python identifier arcrole
    __arcrole = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'arcrole'), 'arcrole', '__httpwww_isotc211_org2005gmd_CI_ResponsibleParty_PropertyType_httpwww_w3_org1999xlinkarcrole', _ImportedBinding_bindings_v1411_write__xlink.arcroleType)
    __arcrole._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 56, 1)
    __arcrole._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 115, 2)
    
    arcrole = property(__arcrole.value, __arcrole.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}title uses Python identifier title
    __title = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'title'), 'title', '__httpwww_isotc211_org2005gmd_CI_ResponsibleParty_PropertyType_httpwww_w3_org1999xlinktitle', _ImportedBinding_bindings_v1411_write__xlink.titleAttrType)
    __title._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 64, 1)
    __title._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 116, 2)
    
    title = property(__title.value, __title.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}show uses Python identifier show
    __show = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'show'), 'show', '__httpwww_isotc211_org2005gmd_CI_ResponsibleParty_PropertyType_httpwww_w3_org1999xlinkshow', _ImportedBinding_bindings_v1411_write__xlink.showType)
    __show._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 70, 1)
    __show._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 117, 2)
    
    show = property(__show.value, __show.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}actuate uses Python identifier actuate
    __actuate = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'actuate'), 'actuate', '__httpwww_isotc211_org2005gmd_CI_ResponsibleParty_PropertyType_httpwww_w3_org1999xlinkactuate', _ImportedBinding_bindings_v1411_write__xlink.actuateType)
    __actuate._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 82, 1)
    __actuate._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 118, 2)
    
    actuate = property(__actuate.value, __actuate.set, None, None)

    _ElementMap.update({
        __CI_ResponsibleParty.name() : __CI_ResponsibleParty
    })
    _AttributeMap.update({
        __uuidref.name() : __uuidref,
        __nilReason.name() : __nilReason,
        __type.name() : __type,
        __href.name() : __href,
        __role.name() : __role,
        __arcrole.name() : __arcrole,
        __title.name() : __title,
        __show.name() : __show,
        __actuate.name() : __actuate
    })
_module_typeBindings.CI_ResponsibleParty_PropertyType = CI_ResponsibleParty_PropertyType
_Namespace_gmd.addCategoryObject('typeBinding', 'CI_ResponsibleParty_PropertyType', CI_ResponsibleParty_PropertyType)


# Complex type {http://www.isotc211.org/2005/gmd}CI_Citation_PropertyType with content type ELEMENT_ONLY
class CI_Citation_PropertyType (pyxb.binding.basis.complexTypeDefinition):
    """Complex type {http://www.isotc211.org/2005/gmd}CI_Citation_PropertyType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'CI_Citation_PropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 68, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.isotc211.org/2005/gmd}CI_Citation uses Python identifier CI_Citation
    __CI_Citation = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'CI_Citation'), 'CI_Citation', '__httpwww_isotc211_org2005gmd_CI_Citation_PropertyType_httpwww_isotc211_org2005gmdCI_Citation', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 66, 1), )

    
    CI_Citation = property(__CI_Citation.value, __CI_Citation.set, None, None)

    
    # Attribute uuidref uses Python identifier uuidref
    __uuidref = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'uuidref'), 'uuidref', '__httpwww_isotc211_org2005gmd_CI_Citation_PropertyType_uuidref', pyxb.binding.datatypes.string)
    __uuidref._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 30, 2)
    __uuidref._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 30, 2)
    
    uuidref = property(__uuidref.value, __uuidref.set, None, None)

    
    # Attribute {http://www.isotc211.org/2005/gco}nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gco, 'nilReason'), 'nilReason', '__httpwww_isotc211_org2005gmd_CI_Citation_PropertyType_httpwww_isotc211_org2005gconilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 33, 1)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 73, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}type uses Python identifier type
    __type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'type'), 'type', '__httpwww_isotc211_org2005gmd_CI_Citation_PropertyType_httpwww_w3_org1999xlinktype', _ImportedBinding_bindings_v1411_write__xlink.typeType, fixed=True, unicode_default='simple')
    __type._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 29, 1)
    __type._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 112, 2)
    
    type = property(__type.value, __type.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}href uses Python identifier href
    __href = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'href'), 'href', '__httpwww_isotc211_org2005gmd_CI_Citation_PropertyType_httpwww_w3_org1999xlinkhref', _ImportedBinding_bindings_v1411_write__xlink.hrefType)
    __href._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 42, 1)
    __href._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 113, 2)
    
    href = property(__href.value, __href.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}role uses Python identifier role
    __role = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'role'), 'role', '__httpwww_isotc211_org2005gmd_CI_Citation_PropertyType_httpwww_w3_org1999xlinkrole', _ImportedBinding_bindings_v1411_write__xlink.roleType)
    __role._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 48, 1)
    __role._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 114, 2)
    
    role = property(__role.value, __role.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}arcrole uses Python identifier arcrole
    __arcrole = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'arcrole'), 'arcrole', '__httpwww_isotc211_org2005gmd_CI_Citation_PropertyType_httpwww_w3_org1999xlinkarcrole', _ImportedBinding_bindings_v1411_write__xlink.arcroleType)
    __arcrole._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 56, 1)
    __arcrole._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 115, 2)
    
    arcrole = property(__arcrole.value, __arcrole.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}title uses Python identifier title
    __title = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'title'), 'title', '__httpwww_isotc211_org2005gmd_CI_Citation_PropertyType_httpwww_w3_org1999xlinktitle', _ImportedBinding_bindings_v1411_write__xlink.titleAttrType)
    __title._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 64, 1)
    __title._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 116, 2)
    
    title = property(__title.value, __title.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}show uses Python identifier show
    __show = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'show'), 'show', '__httpwww_isotc211_org2005gmd_CI_Citation_PropertyType_httpwww_w3_org1999xlinkshow', _ImportedBinding_bindings_v1411_write__xlink.showType)
    __show._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 70, 1)
    __show._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 117, 2)
    
    show = property(__show.value, __show.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}actuate uses Python identifier actuate
    __actuate = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'actuate'), 'actuate', '__httpwww_isotc211_org2005gmd_CI_Citation_PropertyType_httpwww_w3_org1999xlinkactuate', _ImportedBinding_bindings_v1411_write__xlink.actuateType)
    __actuate._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 82, 1)
    __actuate._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 118, 2)
    
    actuate = property(__actuate.value, __actuate.set, None, None)

    _ElementMap.update({
        __CI_Citation.name() : __CI_Citation
    })
    _AttributeMap.update({
        __uuidref.name() : __uuidref,
        __nilReason.name() : __nilReason,
        __type.name() : __type,
        __href.name() : __href,
        __role.name() : __role,
        __arcrole.name() : __arcrole,
        __title.name() : __title,
        __show.name() : __show,
        __actuate.name() : __actuate
    })
_module_typeBindings.CI_Citation_PropertyType = CI_Citation_PropertyType
_Namespace_gmd.addCategoryObject('typeBinding', 'CI_Citation_PropertyType', CI_Citation_PropertyType)


# Complex type {http://www.isotc211.org/2005/gmd}CI_Address_PropertyType with content type ELEMENT_ONLY
class CI_Address_PropertyType (pyxb.binding.basis.complexTypeDefinition):
    """Complex type {http://www.isotc211.org/2005/gmd}CI_Address_PropertyType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'CI_Address_PropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 96, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.isotc211.org/2005/gmd}CI_Address uses Python identifier CI_Address
    __CI_Address = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'CI_Address'), 'CI_Address', '__httpwww_isotc211_org2005gmd_CI_Address_PropertyType_httpwww_isotc211_org2005gmdCI_Address', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 94, 1), )

    
    CI_Address = property(__CI_Address.value, __CI_Address.set, None, None)

    
    # Attribute uuidref uses Python identifier uuidref
    __uuidref = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'uuidref'), 'uuidref', '__httpwww_isotc211_org2005gmd_CI_Address_PropertyType_uuidref', pyxb.binding.datatypes.string)
    __uuidref._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 30, 2)
    __uuidref._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 30, 2)
    
    uuidref = property(__uuidref.value, __uuidref.set, None, None)

    
    # Attribute {http://www.isotc211.org/2005/gco}nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gco, 'nilReason'), 'nilReason', '__httpwww_isotc211_org2005gmd_CI_Address_PropertyType_httpwww_isotc211_org2005gconilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 33, 1)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 101, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}type uses Python identifier type
    __type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'type'), 'type', '__httpwww_isotc211_org2005gmd_CI_Address_PropertyType_httpwww_w3_org1999xlinktype', _ImportedBinding_bindings_v1411_write__xlink.typeType, fixed=True, unicode_default='simple')
    __type._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 29, 1)
    __type._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 112, 2)
    
    type = property(__type.value, __type.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}href uses Python identifier href
    __href = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'href'), 'href', '__httpwww_isotc211_org2005gmd_CI_Address_PropertyType_httpwww_w3_org1999xlinkhref', _ImportedBinding_bindings_v1411_write__xlink.hrefType)
    __href._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 42, 1)
    __href._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 113, 2)
    
    href = property(__href.value, __href.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}role uses Python identifier role
    __role = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'role'), 'role', '__httpwww_isotc211_org2005gmd_CI_Address_PropertyType_httpwww_w3_org1999xlinkrole', _ImportedBinding_bindings_v1411_write__xlink.roleType)
    __role._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 48, 1)
    __role._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 114, 2)
    
    role = property(__role.value, __role.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}arcrole uses Python identifier arcrole
    __arcrole = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'arcrole'), 'arcrole', '__httpwww_isotc211_org2005gmd_CI_Address_PropertyType_httpwww_w3_org1999xlinkarcrole', _ImportedBinding_bindings_v1411_write__xlink.arcroleType)
    __arcrole._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 56, 1)
    __arcrole._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 115, 2)
    
    arcrole = property(__arcrole.value, __arcrole.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}title uses Python identifier title
    __title = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'title'), 'title', '__httpwww_isotc211_org2005gmd_CI_Address_PropertyType_httpwww_w3_org1999xlinktitle', _ImportedBinding_bindings_v1411_write__xlink.titleAttrType)
    __title._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 64, 1)
    __title._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 116, 2)
    
    title = property(__title.value, __title.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}show uses Python identifier show
    __show = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'show'), 'show', '__httpwww_isotc211_org2005gmd_CI_Address_PropertyType_httpwww_w3_org1999xlinkshow', _ImportedBinding_bindings_v1411_write__xlink.showType)
    __show._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 70, 1)
    __show._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 117, 2)
    
    show = property(__show.value, __show.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}actuate uses Python identifier actuate
    __actuate = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'actuate'), 'actuate', '__httpwww_isotc211_org2005gmd_CI_Address_PropertyType_httpwww_w3_org1999xlinkactuate', _ImportedBinding_bindings_v1411_write__xlink.actuateType)
    __actuate._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 82, 1)
    __actuate._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 118, 2)
    
    actuate = property(__actuate.value, __actuate.set, None, None)

    _ElementMap.update({
        __CI_Address.name() : __CI_Address
    })
    _AttributeMap.update({
        __uuidref.name() : __uuidref,
        __nilReason.name() : __nilReason,
        __type.name() : __type,
        __href.name() : __href,
        __role.name() : __role,
        __arcrole.name() : __arcrole,
        __title.name() : __title,
        __show.name() : __show,
        __actuate.name() : __actuate
    })
_module_typeBindings.CI_Address_PropertyType = CI_Address_PropertyType
_Namespace_gmd.addCategoryObject('typeBinding', 'CI_Address_PropertyType', CI_Address_PropertyType)


# Complex type {http://www.isotc211.org/2005/gmd}CI_OnlineResource_PropertyType with content type ELEMENT_ONLY
class CI_OnlineResource_PropertyType (pyxb.binding.basis.complexTypeDefinition):
    """Complex type {http://www.isotc211.org/2005/gmd}CI_OnlineResource_PropertyType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'CI_OnlineResource_PropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 124, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.isotc211.org/2005/gmd}CI_OnlineResource uses Python identifier CI_OnlineResource
    __CI_OnlineResource = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'CI_OnlineResource'), 'CI_OnlineResource', '__httpwww_isotc211_org2005gmd_CI_OnlineResource_PropertyType_httpwww_isotc211_org2005gmdCI_OnlineResource', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 122, 1), )

    
    CI_OnlineResource = property(__CI_OnlineResource.value, __CI_OnlineResource.set, None, None)

    
    # Attribute uuidref uses Python identifier uuidref
    __uuidref = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'uuidref'), 'uuidref', '__httpwww_isotc211_org2005gmd_CI_OnlineResource_PropertyType_uuidref', pyxb.binding.datatypes.string)
    __uuidref._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 30, 2)
    __uuidref._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 30, 2)
    
    uuidref = property(__uuidref.value, __uuidref.set, None, None)

    
    # Attribute {http://www.isotc211.org/2005/gco}nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gco, 'nilReason'), 'nilReason', '__httpwww_isotc211_org2005gmd_CI_OnlineResource_PropertyType_httpwww_isotc211_org2005gconilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 33, 1)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 129, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}type uses Python identifier type
    __type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'type'), 'type', '__httpwww_isotc211_org2005gmd_CI_OnlineResource_PropertyType_httpwww_w3_org1999xlinktype', _ImportedBinding_bindings_v1411_write__xlink.typeType, fixed=True, unicode_default='simple')
    __type._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 29, 1)
    __type._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 112, 2)
    
    type = property(__type.value, __type.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}href uses Python identifier href
    __href = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'href'), 'href', '__httpwww_isotc211_org2005gmd_CI_OnlineResource_PropertyType_httpwww_w3_org1999xlinkhref', _ImportedBinding_bindings_v1411_write__xlink.hrefType)
    __href._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 42, 1)
    __href._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 113, 2)
    
    href = property(__href.value, __href.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}role uses Python identifier role
    __role = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'role'), 'role', '__httpwww_isotc211_org2005gmd_CI_OnlineResource_PropertyType_httpwww_w3_org1999xlinkrole', _ImportedBinding_bindings_v1411_write__xlink.roleType)
    __role._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 48, 1)
    __role._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 114, 2)
    
    role = property(__role.value, __role.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}arcrole uses Python identifier arcrole
    __arcrole = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'arcrole'), 'arcrole', '__httpwww_isotc211_org2005gmd_CI_OnlineResource_PropertyType_httpwww_w3_org1999xlinkarcrole', _ImportedBinding_bindings_v1411_write__xlink.arcroleType)
    __arcrole._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 56, 1)
    __arcrole._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 115, 2)
    
    arcrole = property(__arcrole.value, __arcrole.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}title uses Python identifier title
    __title = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'title'), 'title', '__httpwww_isotc211_org2005gmd_CI_OnlineResource_PropertyType_httpwww_w3_org1999xlinktitle', _ImportedBinding_bindings_v1411_write__xlink.titleAttrType)
    __title._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 64, 1)
    __title._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 116, 2)
    
    title = property(__title.value, __title.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}show uses Python identifier show
    __show = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'show'), 'show', '__httpwww_isotc211_org2005gmd_CI_OnlineResource_PropertyType_httpwww_w3_org1999xlinkshow', _ImportedBinding_bindings_v1411_write__xlink.showType)
    __show._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 70, 1)
    __show._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 117, 2)
    
    show = property(__show.value, __show.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}actuate uses Python identifier actuate
    __actuate = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'actuate'), 'actuate', '__httpwww_isotc211_org2005gmd_CI_OnlineResource_PropertyType_httpwww_w3_org1999xlinkactuate', _ImportedBinding_bindings_v1411_write__xlink.actuateType)
    __actuate._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 82, 1)
    __actuate._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 118, 2)
    
    actuate = property(__actuate.value, __actuate.set, None, None)

    _ElementMap.update({
        __CI_OnlineResource.name() : __CI_OnlineResource
    })
    _AttributeMap.update({
        __uuidref.name() : __uuidref,
        __nilReason.name() : __nilReason,
        __type.name() : __type,
        __href.name() : __href,
        __role.name() : __role,
        __arcrole.name() : __arcrole,
        __title.name() : __title,
        __show.name() : __show,
        __actuate.name() : __actuate
    })
_module_typeBindings.CI_OnlineResource_PropertyType = CI_OnlineResource_PropertyType
_Namespace_gmd.addCategoryObject('typeBinding', 'CI_OnlineResource_PropertyType', CI_OnlineResource_PropertyType)


# Complex type {http://www.isotc211.org/2005/gmd}CI_Contact_PropertyType with content type ELEMENT_ONLY
class CI_Contact_PropertyType (pyxb.binding.basis.complexTypeDefinition):
    """Complex type {http://www.isotc211.org/2005/gmd}CI_Contact_PropertyType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'CI_Contact_PropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 151, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.isotc211.org/2005/gmd}CI_Contact uses Python identifier CI_Contact
    __CI_Contact = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'CI_Contact'), 'CI_Contact', '__httpwww_isotc211_org2005gmd_CI_Contact_PropertyType_httpwww_isotc211_org2005gmdCI_Contact', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 149, 1), )

    
    CI_Contact = property(__CI_Contact.value, __CI_Contact.set, None, None)

    
    # Attribute uuidref uses Python identifier uuidref
    __uuidref = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'uuidref'), 'uuidref', '__httpwww_isotc211_org2005gmd_CI_Contact_PropertyType_uuidref', pyxb.binding.datatypes.string)
    __uuidref._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 30, 2)
    __uuidref._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 30, 2)
    
    uuidref = property(__uuidref.value, __uuidref.set, None, None)

    
    # Attribute {http://www.isotc211.org/2005/gco}nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gco, 'nilReason'), 'nilReason', '__httpwww_isotc211_org2005gmd_CI_Contact_PropertyType_httpwww_isotc211_org2005gconilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 33, 1)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 156, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}type uses Python identifier type
    __type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'type'), 'type', '__httpwww_isotc211_org2005gmd_CI_Contact_PropertyType_httpwww_w3_org1999xlinktype', _ImportedBinding_bindings_v1411_write__xlink.typeType, fixed=True, unicode_default='simple')
    __type._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 29, 1)
    __type._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 112, 2)
    
    type = property(__type.value, __type.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}href uses Python identifier href
    __href = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'href'), 'href', '__httpwww_isotc211_org2005gmd_CI_Contact_PropertyType_httpwww_w3_org1999xlinkhref', _ImportedBinding_bindings_v1411_write__xlink.hrefType)
    __href._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 42, 1)
    __href._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 113, 2)
    
    href = property(__href.value, __href.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}role uses Python identifier role
    __role = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'role'), 'role', '__httpwww_isotc211_org2005gmd_CI_Contact_PropertyType_httpwww_w3_org1999xlinkrole', _ImportedBinding_bindings_v1411_write__xlink.roleType)
    __role._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 48, 1)
    __role._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 114, 2)
    
    role = property(__role.value, __role.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}arcrole uses Python identifier arcrole
    __arcrole = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'arcrole'), 'arcrole', '__httpwww_isotc211_org2005gmd_CI_Contact_PropertyType_httpwww_w3_org1999xlinkarcrole', _ImportedBinding_bindings_v1411_write__xlink.arcroleType)
    __arcrole._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 56, 1)
    __arcrole._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 115, 2)
    
    arcrole = property(__arcrole.value, __arcrole.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}title uses Python identifier title
    __title = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'title'), 'title', '__httpwww_isotc211_org2005gmd_CI_Contact_PropertyType_httpwww_w3_org1999xlinktitle', _ImportedBinding_bindings_v1411_write__xlink.titleAttrType)
    __title._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 64, 1)
    __title._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 116, 2)
    
    title = property(__title.value, __title.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}show uses Python identifier show
    __show = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'show'), 'show', '__httpwww_isotc211_org2005gmd_CI_Contact_PropertyType_httpwww_w3_org1999xlinkshow', _ImportedBinding_bindings_v1411_write__xlink.showType)
    __show._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 70, 1)
    __show._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 117, 2)
    
    show = property(__show.value, __show.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}actuate uses Python identifier actuate
    __actuate = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'actuate'), 'actuate', '__httpwww_isotc211_org2005gmd_CI_Contact_PropertyType_httpwww_w3_org1999xlinkactuate', _ImportedBinding_bindings_v1411_write__xlink.actuateType)
    __actuate._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 82, 1)
    __actuate._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 118, 2)
    
    actuate = property(__actuate.value, __actuate.set, None, None)

    _ElementMap.update({
        __CI_Contact.name() : __CI_Contact
    })
    _AttributeMap.update({
        __uuidref.name() : __uuidref,
        __nilReason.name() : __nilReason,
        __type.name() : __type,
        __href.name() : __href,
        __role.name() : __role,
        __arcrole.name() : __arcrole,
        __title.name() : __title,
        __show.name() : __show,
        __actuate.name() : __actuate
    })
_module_typeBindings.CI_Contact_PropertyType = CI_Contact_PropertyType
_Namespace_gmd.addCategoryObject('typeBinding', 'CI_Contact_PropertyType', CI_Contact_PropertyType)


# Complex type {http://www.isotc211.org/2005/gmd}CI_Telephone_PropertyType with content type ELEMENT_ONLY
class CI_Telephone_PropertyType (pyxb.binding.basis.complexTypeDefinition):
    """Complex type {http://www.isotc211.org/2005/gmd}CI_Telephone_PropertyType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'CI_Telephone_PropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 175, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.isotc211.org/2005/gmd}CI_Telephone uses Python identifier CI_Telephone
    __CI_Telephone = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'CI_Telephone'), 'CI_Telephone', '__httpwww_isotc211_org2005gmd_CI_Telephone_PropertyType_httpwww_isotc211_org2005gmdCI_Telephone', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 173, 1), )

    
    CI_Telephone = property(__CI_Telephone.value, __CI_Telephone.set, None, None)

    
    # Attribute uuidref uses Python identifier uuidref
    __uuidref = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'uuidref'), 'uuidref', '__httpwww_isotc211_org2005gmd_CI_Telephone_PropertyType_uuidref', pyxb.binding.datatypes.string)
    __uuidref._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 30, 2)
    __uuidref._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 30, 2)
    
    uuidref = property(__uuidref.value, __uuidref.set, None, None)

    
    # Attribute {http://www.isotc211.org/2005/gco}nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gco, 'nilReason'), 'nilReason', '__httpwww_isotc211_org2005gmd_CI_Telephone_PropertyType_httpwww_isotc211_org2005gconilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 33, 1)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 180, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}type uses Python identifier type
    __type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'type'), 'type', '__httpwww_isotc211_org2005gmd_CI_Telephone_PropertyType_httpwww_w3_org1999xlinktype', _ImportedBinding_bindings_v1411_write__xlink.typeType, fixed=True, unicode_default='simple')
    __type._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 29, 1)
    __type._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 112, 2)
    
    type = property(__type.value, __type.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}href uses Python identifier href
    __href = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'href'), 'href', '__httpwww_isotc211_org2005gmd_CI_Telephone_PropertyType_httpwww_w3_org1999xlinkhref', _ImportedBinding_bindings_v1411_write__xlink.hrefType)
    __href._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 42, 1)
    __href._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 113, 2)
    
    href = property(__href.value, __href.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}role uses Python identifier role
    __role = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'role'), 'role', '__httpwww_isotc211_org2005gmd_CI_Telephone_PropertyType_httpwww_w3_org1999xlinkrole', _ImportedBinding_bindings_v1411_write__xlink.roleType)
    __role._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 48, 1)
    __role._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 114, 2)
    
    role = property(__role.value, __role.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}arcrole uses Python identifier arcrole
    __arcrole = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'arcrole'), 'arcrole', '__httpwww_isotc211_org2005gmd_CI_Telephone_PropertyType_httpwww_w3_org1999xlinkarcrole', _ImportedBinding_bindings_v1411_write__xlink.arcroleType)
    __arcrole._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 56, 1)
    __arcrole._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 115, 2)
    
    arcrole = property(__arcrole.value, __arcrole.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}title uses Python identifier title
    __title = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'title'), 'title', '__httpwww_isotc211_org2005gmd_CI_Telephone_PropertyType_httpwww_w3_org1999xlinktitle', _ImportedBinding_bindings_v1411_write__xlink.titleAttrType)
    __title._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 64, 1)
    __title._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 116, 2)
    
    title = property(__title.value, __title.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}show uses Python identifier show
    __show = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'show'), 'show', '__httpwww_isotc211_org2005gmd_CI_Telephone_PropertyType_httpwww_w3_org1999xlinkshow', _ImportedBinding_bindings_v1411_write__xlink.showType)
    __show._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 70, 1)
    __show._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 117, 2)
    
    show = property(__show.value, __show.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}actuate uses Python identifier actuate
    __actuate = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'actuate'), 'actuate', '__httpwww_isotc211_org2005gmd_CI_Telephone_PropertyType_httpwww_w3_org1999xlinkactuate', _ImportedBinding_bindings_v1411_write__xlink.actuateType)
    __actuate._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 82, 1)
    __actuate._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 118, 2)
    
    actuate = property(__actuate.value, __actuate.set, None, None)

    _ElementMap.update({
        __CI_Telephone.name() : __CI_Telephone
    })
    _AttributeMap.update({
        __uuidref.name() : __uuidref,
        __nilReason.name() : __nilReason,
        __type.name() : __type,
        __href.name() : __href,
        __role.name() : __role,
        __arcrole.name() : __arcrole,
        __title.name() : __title,
        __show.name() : __show,
        __actuate.name() : __actuate
    })
_module_typeBindings.CI_Telephone_PropertyType = CI_Telephone_PropertyType
_Namespace_gmd.addCategoryObject('typeBinding', 'CI_Telephone_PropertyType', CI_Telephone_PropertyType)


# Complex type {http://www.isotc211.org/2005/gmd}CI_Date_PropertyType with content type ELEMENT_ONLY
class CI_Date_PropertyType (pyxb.binding.basis.complexTypeDefinition):
    """Complex type {http://www.isotc211.org/2005/gmd}CI_Date_PropertyType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'CI_Date_PropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 196, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.isotc211.org/2005/gmd}CI_Date uses Python identifier CI_Date
    __CI_Date = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'CI_Date'), 'CI_Date', '__httpwww_isotc211_org2005gmd_CI_Date_PropertyType_httpwww_isotc211_org2005gmdCI_Date', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 194, 1), )

    
    CI_Date = property(__CI_Date.value, __CI_Date.set, None, None)

    
    # Attribute uuidref uses Python identifier uuidref
    __uuidref = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'uuidref'), 'uuidref', '__httpwww_isotc211_org2005gmd_CI_Date_PropertyType_uuidref', pyxb.binding.datatypes.string)
    __uuidref._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 30, 2)
    __uuidref._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 30, 2)
    
    uuidref = property(__uuidref.value, __uuidref.set, None, None)

    
    # Attribute {http://www.isotc211.org/2005/gco}nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gco, 'nilReason'), 'nilReason', '__httpwww_isotc211_org2005gmd_CI_Date_PropertyType_httpwww_isotc211_org2005gconilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 33, 1)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 201, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}type uses Python identifier type
    __type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'type'), 'type', '__httpwww_isotc211_org2005gmd_CI_Date_PropertyType_httpwww_w3_org1999xlinktype', _ImportedBinding_bindings_v1411_write__xlink.typeType, fixed=True, unicode_default='simple')
    __type._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 29, 1)
    __type._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 112, 2)
    
    type = property(__type.value, __type.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}href uses Python identifier href
    __href = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'href'), 'href', '__httpwww_isotc211_org2005gmd_CI_Date_PropertyType_httpwww_w3_org1999xlinkhref', _ImportedBinding_bindings_v1411_write__xlink.hrefType)
    __href._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 42, 1)
    __href._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 113, 2)
    
    href = property(__href.value, __href.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}role uses Python identifier role
    __role = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'role'), 'role', '__httpwww_isotc211_org2005gmd_CI_Date_PropertyType_httpwww_w3_org1999xlinkrole', _ImportedBinding_bindings_v1411_write__xlink.roleType)
    __role._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 48, 1)
    __role._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 114, 2)
    
    role = property(__role.value, __role.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}arcrole uses Python identifier arcrole
    __arcrole = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'arcrole'), 'arcrole', '__httpwww_isotc211_org2005gmd_CI_Date_PropertyType_httpwww_w3_org1999xlinkarcrole', _ImportedBinding_bindings_v1411_write__xlink.arcroleType)
    __arcrole._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 56, 1)
    __arcrole._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 115, 2)
    
    arcrole = property(__arcrole.value, __arcrole.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}title uses Python identifier title
    __title = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'title'), 'title', '__httpwww_isotc211_org2005gmd_CI_Date_PropertyType_httpwww_w3_org1999xlinktitle', _ImportedBinding_bindings_v1411_write__xlink.titleAttrType)
    __title._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 64, 1)
    __title._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 116, 2)
    
    title = property(__title.value, __title.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}show uses Python identifier show
    __show = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'show'), 'show', '__httpwww_isotc211_org2005gmd_CI_Date_PropertyType_httpwww_w3_org1999xlinkshow', _ImportedBinding_bindings_v1411_write__xlink.showType)
    __show._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 70, 1)
    __show._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 117, 2)
    
    show = property(__show.value, __show.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}actuate uses Python identifier actuate
    __actuate = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'actuate'), 'actuate', '__httpwww_isotc211_org2005gmd_CI_Date_PropertyType_httpwww_w3_org1999xlinkactuate', _ImportedBinding_bindings_v1411_write__xlink.actuateType)
    __actuate._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 82, 1)
    __actuate._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 118, 2)
    
    actuate = property(__actuate.value, __actuate.set, None, None)

    _ElementMap.update({
        __CI_Date.name() : __CI_Date
    })
    _AttributeMap.update({
        __uuidref.name() : __uuidref,
        __nilReason.name() : __nilReason,
        __type.name() : __type,
        __href.name() : __href,
        __role.name() : __role,
        __arcrole.name() : __arcrole,
        __title.name() : __title,
        __show.name() : __show,
        __actuate.name() : __actuate
    })
_module_typeBindings.CI_Date_PropertyType = CI_Date_PropertyType
_Namespace_gmd.addCategoryObject('typeBinding', 'CI_Date_PropertyType', CI_Date_PropertyType)


# Complex type {http://www.isotc211.org/2005/gmd}CI_Series_PropertyType with content type ELEMENT_ONLY
class CI_Series_PropertyType (pyxb.binding.basis.complexTypeDefinition):
    """Complex type {http://www.isotc211.org/2005/gmd}CI_Series_PropertyType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'CI_Series_PropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 218, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.isotc211.org/2005/gmd}CI_Series uses Python identifier CI_Series
    __CI_Series = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'CI_Series'), 'CI_Series', '__httpwww_isotc211_org2005gmd_CI_Series_PropertyType_httpwww_isotc211_org2005gmdCI_Series', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 216, 1), )

    
    CI_Series = property(__CI_Series.value, __CI_Series.set, None, None)

    
    # Attribute uuidref uses Python identifier uuidref
    __uuidref = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'uuidref'), 'uuidref', '__httpwww_isotc211_org2005gmd_CI_Series_PropertyType_uuidref', pyxb.binding.datatypes.string)
    __uuidref._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 30, 2)
    __uuidref._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 30, 2)
    
    uuidref = property(__uuidref.value, __uuidref.set, None, None)

    
    # Attribute {http://www.isotc211.org/2005/gco}nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gco, 'nilReason'), 'nilReason', '__httpwww_isotc211_org2005gmd_CI_Series_PropertyType_httpwww_isotc211_org2005gconilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 33, 1)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 223, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}type uses Python identifier type
    __type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'type'), 'type', '__httpwww_isotc211_org2005gmd_CI_Series_PropertyType_httpwww_w3_org1999xlinktype', _ImportedBinding_bindings_v1411_write__xlink.typeType, fixed=True, unicode_default='simple')
    __type._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 29, 1)
    __type._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 112, 2)
    
    type = property(__type.value, __type.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}href uses Python identifier href
    __href = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'href'), 'href', '__httpwww_isotc211_org2005gmd_CI_Series_PropertyType_httpwww_w3_org1999xlinkhref', _ImportedBinding_bindings_v1411_write__xlink.hrefType)
    __href._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 42, 1)
    __href._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 113, 2)
    
    href = property(__href.value, __href.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}role uses Python identifier role
    __role = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'role'), 'role', '__httpwww_isotc211_org2005gmd_CI_Series_PropertyType_httpwww_w3_org1999xlinkrole', _ImportedBinding_bindings_v1411_write__xlink.roleType)
    __role._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 48, 1)
    __role._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 114, 2)
    
    role = property(__role.value, __role.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}arcrole uses Python identifier arcrole
    __arcrole = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'arcrole'), 'arcrole', '__httpwww_isotc211_org2005gmd_CI_Series_PropertyType_httpwww_w3_org1999xlinkarcrole', _ImportedBinding_bindings_v1411_write__xlink.arcroleType)
    __arcrole._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 56, 1)
    __arcrole._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 115, 2)
    
    arcrole = property(__arcrole.value, __arcrole.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}title uses Python identifier title
    __title = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'title'), 'title', '__httpwww_isotc211_org2005gmd_CI_Series_PropertyType_httpwww_w3_org1999xlinktitle', _ImportedBinding_bindings_v1411_write__xlink.titleAttrType)
    __title._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 64, 1)
    __title._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 116, 2)
    
    title = property(__title.value, __title.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}show uses Python identifier show
    __show = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'show'), 'show', '__httpwww_isotc211_org2005gmd_CI_Series_PropertyType_httpwww_w3_org1999xlinkshow', _ImportedBinding_bindings_v1411_write__xlink.showType)
    __show._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 70, 1)
    __show._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 117, 2)
    
    show = property(__show.value, __show.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}actuate uses Python identifier actuate
    __actuate = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'actuate'), 'actuate', '__httpwww_isotc211_org2005gmd_CI_Series_PropertyType_httpwww_w3_org1999xlinkactuate', _ImportedBinding_bindings_v1411_write__xlink.actuateType)
    __actuate._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 82, 1)
    __actuate._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 118, 2)
    
    actuate = property(__actuate.value, __actuate.set, None, None)

    _ElementMap.update({
        __CI_Series.name() : __CI_Series
    })
    _AttributeMap.update({
        __uuidref.name() : __uuidref,
        __nilReason.name() : __nilReason,
        __type.name() : __type,
        __href.name() : __href,
        __role.name() : __role,
        __arcrole.name() : __arcrole,
        __title.name() : __title,
        __show.name() : __show,
        __actuate.name() : __actuate
    })
_module_typeBindings.CI_Series_PropertyType = CI_Series_PropertyType
_Namespace_gmd.addCategoryObject('typeBinding', 'CI_Series_PropertyType', CI_Series_PropertyType)


# Complex type {http://www.isotc211.org/2005/gmd}URL_PropertyType with content type ELEMENT_ONLY
class URL_PropertyType (pyxb.binding.basis.complexTypeDefinition):
    """Complex type {http://www.isotc211.org/2005/gmd}URL_PropertyType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'URL_PropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 229, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.isotc211.org/2005/gmd}URL uses Python identifier URL
    __URL = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'URL'), 'URL', '__httpwww_isotc211_org2005gmd_URL_PropertyType_httpwww_isotc211_org2005gmdURL', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 227, 1), )

    
    URL = property(__URL.value, __URL.set, None, None)

    
    # Attribute {http://www.isotc211.org/2005/gco}nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gco, 'nilReason'), 'nilReason', '__httpwww_isotc211_org2005gmd_URL_PropertyType_httpwww_isotc211_org2005gconilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 33, 1)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 233, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    _ElementMap.update({
        __URL.name() : __URL
    })
    _AttributeMap.update({
        __nilReason.name() : __nilReason
    })
_module_typeBindings.URL_PropertyType = URL_PropertyType
_Namespace_gmd.addCategoryObject('typeBinding', 'URL_PropertyType', URL_PropertyType)


# Complex type {http://www.isotc211.org/2005/gmd}CI_RoleCode_PropertyType with content type ELEMENT_ONLY
class CI_RoleCode_PropertyType (pyxb.binding.basis.complexTypeDefinition):
    """Complex type {http://www.isotc211.org/2005/gmd}CI_RoleCode_PropertyType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'CI_RoleCode_PropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 239, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.isotc211.org/2005/gmd}CI_RoleCode uses Python identifier CI_RoleCode
    __CI_RoleCode = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'CI_RoleCode'), 'CI_RoleCode', '__httpwww_isotc211_org2005gmd_CI_RoleCode_PropertyType_httpwww_isotc211_org2005gmdCI_RoleCode', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 237, 1), )

    
    CI_RoleCode = property(__CI_RoleCode.value, __CI_RoleCode.set, None, None)

    
    # Attribute {http://www.isotc211.org/2005/gco}nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gco, 'nilReason'), 'nilReason', '__httpwww_isotc211_org2005gmd_CI_RoleCode_PropertyType_httpwww_isotc211_org2005gconilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 33, 1)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 243, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    _ElementMap.update({
        __CI_RoleCode.name() : __CI_RoleCode
    })
    _AttributeMap.update({
        __nilReason.name() : __nilReason
    })
_module_typeBindings.CI_RoleCode_PropertyType = CI_RoleCode_PropertyType
_Namespace_gmd.addCategoryObject('typeBinding', 'CI_RoleCode_PropertyType', CI_RoleCode_PropertyType)


# Complex type {http://www.isotc211.org/2005/gmd}CI_PresentationFormCode_PropertyType with content type ELEMENT_ONLY
class CI_PresentationFormCode_PropertyType (pyxb.binding.basis.complexTypeDefinition):
    """Complex type {http://www.isotc211.org/2005/gmd}CI_PresentationFormCode_PropertyType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'CI_PresentationFormCode_PropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 249, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.isotc211.org/2005/gmd}CI_PresentationFormCode uses Python identifier CI_PresentationFormCode
    __CI_PresentationFormCode = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'CI_PresentationFormCode'), 'CI_PresentationFormCode', '__httpwww_isotc211_org2005gmd_CI_PresentationFormCode_PropertyType_httpwww_isotc211_org2005gmdCI_PresentationFormCode', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 247, 1), )

    
    CI_PresentationFormCode = property(__CI_PresentationFormCode.value, __CI_PresentationFormCode.set, None, None)

    
    # Attribute {http://www.isotc211.org/2005/gco}nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gco, 'nilReason'), 'nilReason', '__httpwww_isotc211_org2005gmd_CI_PresentationFormCode_PropertyType_httpwww_isotc211_org2005gconilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 33, 1)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 253, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    _ElementMap.update({
        __CI_PresentationFormCode.name() : __CI_PresentationFormCode
    })
    _AttributeMap.update({
        __nilReason.name() : __nilReason
    })
_module_typeBindings.CI_PresentationFormCode_PropertyType = CI_PresentationFormCode_PropertyType
_Namespace_gmd.addCategoryObject('typeBinding', 'CI_PresentationFormCode_PropertyType', CI_PresentationFormCode_PropertyType)


# Complex type {http://www.isotc211.org/2005/gmd}CI_OnLineFunctionCode_PropertyType with content type ELEMENT_ONLY
class CI_OnLineFunctionCode_PropertyType (pyxb.binding.basis.complexTypeDefinition):
    """Complex type {http://www.isotc211.org/2005/gmd}CI_OnLineFunctionCode_PropertyType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'CI_OnLineFunctionCode_PropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 259, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.isotc211.org/2005/gmd}CI_OnLineFunctionCode uses Python identifier CI_OnLineFunctionCode
    __CI_OnLineFunctionCode = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'CI_OnLineFunctionCode'), 'CI_OnLineFunctionCode', '__httpwww_isotc211_org2005gmd_CI_OnLineFunctionCode_PropertyType_httpwww_isotc211_org2005gmdCI_OnLineFunctionCode', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 257, 1), )

    
    CI_OnLineFunctionCode = property(__CI_OnLineFunctionCode.value, __CI_OnLineFunctionCode.set, None, None)

    
    # Attribute {http://www.isotc211.org/2005/gco}nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gco, 'nilReason'), 'nilReason', '__httpwww_isotc211_org2005gmd_CI_OnLineFunctionCode_PropertyType_httpwww_isotc211_org2005gconilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 33, 1)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 263, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    _ElementMap.update({
        __CI_OnLineFunctionCode.name() : __CI_OnLineFunctionCode
    })
    _AttributeMap.update({
        __nilReason.name() : __nilReason
    })
_module_typeBindings.CI_OnLineFunctionCode_PropertyType = CI_OnLineFunctionCode_PropertyType
_Namespace_gmd.addCategoryObject('typeBinding', 'CI_OnLineFunctionCode_PropertyType', CI_OnLineFunctionCode_PropertyType)


# Complex type {http://www.isotc211.org/2005/gmd}CI_DateTypeCode_PropertyType with content type ELEMENT_ONLY
class CI_DateTypeCode_PropertyType (pyxb.binding.basis.complexTypeDefinition):
    """Complex type {http://www.isotc211.org/2005/gmd}CI_DateTypeCode_PropertyType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'CI_DateTypeCode_PropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 269, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.isotc211.org/2005/gmd}CI_DateTypeCode uses Python identifier CI_DateTypeCode
    __CI_DateTypeCode = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'CI_DateTypeCode'), 'CI_DateTypeCode', '__httpwww_isotc211_org2005gmd_CI_DateTypeCode_PropertyType_httpwww_isotc211_org2005gmdCI_DateTypeCode', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 267, 1), )

    
    CI_DateTypeCode = property(__CI_DateTypeCode.value, __CI_DateTypeCode.set, None, None)

    
    # Attribute {http://www.isotc211.org/2005/gco}nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gco, 'nilReason'), 'nilReason', '__httpwww_isotc211_org2005gmd_CI_DateTypeCode_PropertyType_httpwww_isotc211_org2005gconilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 33, 1)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 273, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    _ElementMap.update({
        __CI_DateTypeCode.name() : __CI_DateTypeCode
    })
    _AttributeMap.update({
        __nilReason.name() : __nilReason
    })
_module_typeBindings.CI_DateTypeCode_PropertyType = CI_DateTypeCode_PropertyType
_Namespace_gmd.addCategoryObject('typeBinding', 'CI_DateTypeCode_PropertyType', CI_DateTypeCode_PropertyType)


# Complex type {http://www.isotc211.org/2005/gmd}MD_Constraints_PropertyType with content type ELEMENT_ONLY
class MD_Constraints_PropertyType (pyxb.binding.basis.complexTypeDefinition):
    """Complex type {http://www.isotc211.org/2005/gmd}MD_Constraints_PropertyType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_Constraints_PropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/constraints.xsd', 28, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.isotc211.org/2005/gmd}MD_Constraints uses Python identifier MD_Constraints
    __MD_Constraints = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_Constraints'), 'MD_Constraints', '__httpwww_isotc211_org2005gmd_MD_Constraints_PropertyType_httpwww_isotc211_org2005gmdMD_Constraints', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/constraints.xsd', 26, 1), )

    
    MD_Constraints = property(__MD_Constraints.value, __MD_Constraints.set, None, None)

    
    # Attribute uuidref uses Python identifier uuidref
    __uuidref = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'uuidref'), 'uuidref', '__httpwww_isotc211_org2005gmd_MD_Constraints_PropertyType_uuidref', pyxb.binding.datatypes.string)
    __uuidref._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 30, 2)
    __uuidref._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 30, 2)
    
    uuidref = property(__uuidref.value, __uuidref.set, None, None)

    
    # Attribute {http://www.isotc211.org/2005/gco}nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gco, 'nilReason'), 'nilReason', '__httpwww_isotc211_org2005gmd_MD_Constraints_PropertyType_httpwww_isotc211_org2005gconilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 33, 1)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/constraints.xsd', 33, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}type uses Python identifier type
    __type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'type'), 'type', '__httpwww_isotc211_org2005gmd_MD_Constraints_PropertyType_httpwww_w3_org1999xlinktype', _ImportedBinding_bindings_v1411_write__xlink.typeType, fixed=True, unicode_default='simple')
    __type._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 29, 1)
    __type._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 112, 2)
    
    type = property(__type.value, __type.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}href uses Python identifier href
    __href = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'href'), 'href', '__httpwww_isotc211_org2005gmd_MD_Constraints_PropertyType_httpwww_w3_org1999xlinkhref', _ImportedBinding_bindings_v1411_write__xlink.hrefType)
    __href._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 42, 1)
    __href._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 113, 2)
    
    href = property(__href.value, __href.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}role uses Python identifier role
    __role = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'role'), 'role', '__httpwww_isotc211_org2005gmd_MD_Constraints_PropertyType_httpwww_w3_org1999xlinkrole', _ImportedBinding_bindings_v1411_write__xlink.roleType)
    __role._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 48, 1)
    __role._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 114, 2)
    
    role = property(__role.value, __role.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}arcrole uses Python identifier arcrole
    __arcrole = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'arcrole'), 'arcrole', '__httpwww_isotc211_org2005gmd_MD_Constraints_PropertyType_httpwww_w3_org1999xlinkarcrole', _ImportedBinding_bindings_v1411_write__xlink.arcroleType)
    __arcrole._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 56, 1)
    __arcrole._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 115, 2)
    
    arcrole = property(__arcrole.value, __arcrole.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}title uses Python identifier title
    __title = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'title'), 'title', '__httpwww_isotc211_org2005gmd_MD_Constraints_PropertyType_httpwww_w3_org1999xlinktitle', _ImportedBinding_bindings_v1411_write__xlink.titleAttrType)
    __title._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 64, 1)
    __title._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 116, 2)
    
    title = property(__title.value, __title.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}show uses Python identifier show
    __show = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'show'), 'show', '__httpwww_isotc211_org2005gmd_MD_Constraints_PropertyType_httpwww_w3_org1999xlinkshow', _ImportedBinding_bindings_v1411_write__xlink.showType)
    __show._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 70, 1)
    __show._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 117, 2)
    
    show = property(__show.value, __show.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}actuate uses Python identifier actuate
    __actuate = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'actuate'), 'actuate', '__httpwww_isotc211_org2005gmd_MD_Constraints_PropertyType_httpwww_w3_org1999xlinkactuate', _ImportedBinding_bindings_v1411_write__xlink.actuateType)
    __actuate._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 82, 1)
    __actuate._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 118, 2)
    
    actuate = property(__actuate.value, __actuate.set, None, None)

    _ElementMap.update({
        __MD_Constraints.name() : __MD_Constraints
    })
    _AttributeMap.update({
        __uuidref.name() : __uuidref,
        __nilReason.name() : __nilReason,
        __type.name() : __type,
        __href.name() : __href,
        __role.name() : __role,
        __arcrole.name() : __arcrole,
        __title.name() : __title,
        __show.name() : __show,
        __actuate.name() : __actuate
    })
_module_typeBindings.MD_Constraints_PropertyType = MD_Constraints_PropertyType
_Namespace_gmd.addCategoryObject('typeBinding', 'MD_Constraints_PropertyType', MD_Constraints_PropertyType)


# Complex type {http://www.isotc211.org/2005/gmd}MD_LegalConstraints_Type with content type ELEMENT_ONLY
class MD_LegalConstraints_Type (MD_Constraints_Type):
    """Restrictions and legal prerequisites for accessing and using the dataset."""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_LegalConstraints_Type')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/constraints.xsd', 36, 1)
    _ElementMap = MD_Constraints_Type._ElementMap.copy()
    _AttributeMap = MD_Constraints_Type._AttributeMap.copy()
    # Base type is MD_Constraints_Type
    
    # Element useLimitation ({http://www.isotc211.org/2005/gmd}useLimitation) inherited from {http://www.isotc211.org/2005/gmd}MD_Constraints_Type
    
    # Element {http://www.isotc211.org/2005/gmd}accessConstraints uses Python identifier accessConstraints
    __accessConstraints = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'accessConstraints'), 'accessConstraints', '__httpwww_isotc211_org2005gmd_MD_LegalConstraints_Type_httpwww_isotc211_org2005gmdaccessConstraints', True, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/constraints.xsd', 43, 5), )

    
    accessConstraints = property(__accessConstraints.value, __accessConstraints.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}useConstraints uses Python identifier useConstraints
    __useConstraints = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'useConstraints'), 'useConstraints', '__httpwww_isotc211_org2005gmd_MD_LegalConstraints_Type_httpwww_isotc211_org2005gmduseConstraints', True, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/constraints.xsd', 44, 5), )

    
    useConstraints = property(__useConstraints.value, __useConstraints.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}otherConstraints uses Python identifier otherConstraints
    __otherConstraints = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'otherConstraints'), 'otherConstraints', '__httpwww_isotc211_org2005gmd_MD_LegalConstraints_Type_httpwww_isotc211_org2005gmdotherConstraints', True, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/constraints.xsd', 45, 5), )

    
    otherConstraints = property(__otherConstraints.value, __otherConstraints.set, None, None)

    
    # Attribute id inherited from {http://www.isotc211.org/2005/gco}AbstractObject_Type
    
    # Attribute uuid inherited from {http://www.isotc211.org/2005/gco}AbstractObject_Type
    _ElementMap.update({
        __accessConstraints.name() : __accessConstraints,
        __useConstraints.name() : __useConstraints,
        __otherConstraints.name() : __otherConstraints
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.MD_LegalConstraints_Type = MD_LegalConstraints_Type
_Namespace_gmd.addCategoryObject('typeBinding', 'MD_LegalConstraints_Type', MD_LegalConstraints_Type)


# Complex type {http://www.isotc211.org/2005/gmd}MD_LegalConstraints_PropertyType with content type ELEMENT_ONLY
class MD_LegalConstraints_PropertyType (pyxb.binding.basis.complexTypeDefinition):
    """Complex type {http://www.isotc211.org/2005/gmd}MD_LegalConstraints_PropertyType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_LegalConstraints_PropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/constraints.xsd', 53, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.isotc211.org/2005/gmd}MD_LegalConstraints uses Python identifier MD_LegalConstraints
    __MD_LegalConstraints = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_LegalConstraints'), 'MD_LegalConstraints', '__httpwww_isotc211_org2005gmd_MD_LegalConstraints_PropertyType_httpwww_isotc211_org2005gmdMD_LegalConstraints', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/constraints.xsd', 51, 1), )

    
    MD_LegalConstraints = property(__MD_LegalConstraints.value, __MD_LegalConstraints.set, None, None)

    
    # Attribute uuidref uses Python identifier uuidref
    __uuidref = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'uuidref'), 'uuidref', '__httpwww_isotc211_org2005gmd_MD_LegalConstraints_PropertyType_uuidref', pyxb.binding.datatypes.string)
    __uuidref._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 30, 2)
    __uuidref._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 30, 2)
    
    uuidref = property(__uuidref.value, __uuidref.set, None, None)

    
    # Attribute {http://www.isotc211.org/2005/gco}nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gco, 'nilReason'), 'nilReason', '__httpwww_isotc211_org2005gmd_MD_LegalConstraints_PropertyType_httpwww_isotc211_org2005gconilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 33, 1)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/constraints.xsd', 58, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}type uses Python identifier type
    __type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'type'), 'type', '__httpwww_isotc211_org2005gmd_MD_LegalConstraints_PropertyType_httpwww_w3_org1999xlinktype', _ImportedBinding_bindings_v1411_write__xlink.typeType, fixed=True, unicode_default='simple')
    __type._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 29, 1)
    __type._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 112, 2)
    
    type = property(__type.value, __type.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}href uses Python identifier href
    __href = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'href'), 'href', '__httpwww_isotc211_org2005gmd_MD_LegalConstraints_PropertyType_httpwww_w3_org1999xlinkhref', _ImportedBinding_bindings_v1411_write__xlink.hrefType)
    __href._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 42, 1)
    __href._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 113, 2)
    
    href = property(__href.value, __href.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}role uses Python identifier role
    __role = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'role'), 'role', '__httpwww_isotc211_org2005gmd_MD_LegalConstraints_PropertyType_httpwww_w3_org1999xlinkrole', _ImportedBinding_bindings_v1411_write__xlink.roleType)
    __role._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 48, 1)
    __role._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 114, 2)
    
    role = property(__role.value, __role.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}arcrole uses Python identifier arcrole
    __arcrole = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'arcrole'), 'arcrole', '__httpwww_isotc211_org2005gmd_MD_LegalConstraints_PropertyType_httpwww_w3_org1999xlinkarcrole', _ImportedBinding_bindings_v1411_write__xlink.arcroleType)
    __arcrole._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 56, 1)
    __arcrole._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 115, 2)
    
    arcrole = property(__arcrole.value, __arcrole.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}title uses Python identifier title
    __title = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'title'), 'title', '__httpwww_isotc211_org2005gmd_MD_LegalConstraints_PropertyType_httpwww_w3_org1999xlinktitle', _ImportedBinding_bindings_v1411_write__xlink.titleAttrType)
    __title._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 64, 1)
    __title._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 116, 2)
    
    title = property(__title.value, __title.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}show uses Python identifier show
    __show = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'show'), 'show', '__httpwww_isotc211_org2005gmd_MD_LegalConstraints_PropertyType_httpwww_w3_org1999xlinkshow', _ImportedBinding_bindings_v1411_write__xlink.showType)
    __show._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 70, 1)
    __show._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 117, 2)
    
    show = property(__show.value, __show.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}actuate uses Python identifier actuate
    __actuate = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'actuate'), 'actuate', '__httpwww_isotc211_org2005gmd_MD_LegalConstraints_PropertyType_httpwww_w3_org1999xlinkactuate', _ImportedBinding_bindings_v1411_write__xlink.actuateType)
    __actuate._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 82, 1)
    __actuate._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 118, 2)
    
    actuate = property(__actuate.value, __actuate.set, None, None)

    _ElementMap.update({
        __MD_LegalConstraints.name() : __MD_LegalConstraints
    })
    _AttributeMap.update({
        __uuidref.name() : __uuidref,
        __nilReason.name() : __nilReason,
        __type.name() : __type,
        __href.name() : __href,
        __role.name() : __role,
        __arcrole.name() : __arcrole,
        __title.name() : __title,
        __show.name() : __show,
        __actuate.name() : __actuate
    })
_module_typeBindings.MD_LegalConstraints_PropertyType = MD_LegalConstraints_PropertyType
_Namespace_gmd.addCategoryObject('typeBinding', 'MD_LegalConstraints_PropertyType', MD_LegalConstraints_PropertyType)


# Complex type {http://www.isotc211.org/2005/gmd}MD_SecurityConstraints_Type with content type ELEMENT_ONLY
class MD_SecurityConstraints_Type (MD_Constraints_Type):
    """Handling restrictions imposed on the dataset because of national security, privacy, or other concerns"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_SecurityConstraints_Type')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/constraints.xsd', 61, 1)
    _ElementMap = MD_Constraints_Type._ElementMap.copy()
    _AttributeMap = MD_Constraints_Type._AttributeMap.copy()
    # Base type is MD_Constraints_Type
    
    # Element useLimitation ({http://www.isotc211.org/2005/gmd}useLimitation) inherited from {http://www.isotc211.org/2005/gmd}MD_Constraints_Type
    
    # Element {http://www.isotc211.org/2005/gmd}classification uses Python identifier classification
    __classification = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'classification'), 'classification', '__httpwww_isotc211_org2005gmd_MD_SecurityConstraints_Type_httpwww_isotc211_org2005gmdclassification', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/constraints.xsd', 68, 5), )

    
    classification = property(__classification.value, __classification.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}userNote uses Python identifier userNote
    __userNote = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'userNote'), 'userNote', '__httpwww_isotc211_org2005gmd_MD_SecurityConstraints_Type_httpwww_isotc211_org2005gmduserNote', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/constraints.xsd', 69, 5), )

    
    userNote = property(__userNote.value, __userNote.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}classificationSystem uses Python identifier classificationSystem
    __classificationSystem = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'classificationSystem'), 'classificationSystem', '__httpwww_isotc211_org2005gmd_MD_SecurityConstraints_Type_httpwww_isotc211_org2005gmdclassificationSystem', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/constraints.xsd', 70, 5), )

    
    classificationSystem = property(__classificationSystem.value, __classificationSystem.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}handlingDescription uses Python identifier handlingDescription
    __handlingDescription = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'handlingDescription'), 'handlingDescription', '__httpwww_isotc211_org2005gmd_MD_SecurityConstraints_Type_httpwww_isotc211_org2005gmdhandlingDescription', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/constraints.xsd', 71, 5), )

    
    handlingDescription = property(__handlingDescription.value, __handlingDescription.set, None, None)

    
    # Attribute id inherited from {http://www.isotc211.org/2005/gco}AbstractObject_Type
    
    # Attribute uuid inherited from {http://www.isotc211.org/2005/gco}AbstractObject_Type
    _ElementMap.update({
        __classification.name() : __classification,
        __userNote.name() : __userNote,
        __classificationSystem.name() : __classificationSystem,
        __handlingDescription.name() : __handlingDescription
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.MD_SecurityConstraints_Type = MD_SecurityConstraints_Type
_Namespace_gmd.addCategoryObject('typeBinding', 'MD_SecurityConstraints_Type', MD_SecurityConstraints_Type)


# Complex type {http://www.isotc211.org/2005/gmd}MD_SecurityConstraints_PropertyType with content type ELEMENT_ONLY
class MD_SecurityConstraints_PropertyType (pyxb.binding.basis.complexTypeDefinition):
    """Complex type {http://www.isotc211.org/2005/gmd}MD_SecurityConstraints_PropertyType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_SecurityConstraints_PropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/constraints.xsd', 79, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.isotc211.org/2005/gmd}MD_SecurityConstraints uses Python identifier MD_SecurityConstraints
    __MD_SecurityConstraints = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_SecurityConstraints'), 'MD_SecurityConstraints', '__httpwww_isotc211_org2005gmd_MD_SecurityConstraints_PropertyType_httpwww_isotc211_org2005gmdMD_SecurityConstraints', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/constraints.xsd', 77, 1), )

    
    MD_SecurityConstraints = property(__MD_SecurityConstraints.value, __MD_SecurityConstraints.set, None, None)

    
    # Attribute uuidref uses Python identifier uuidref
    __uuidref = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'uuidref'), 'uuidref', '__httpwww_isotc211_org2005gmd_MD_SecurityConstraints_PropertyType_uuidref', pyxb.binding.datatypes.string)
    __uuidref._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 30, 2)
    __uuidref._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 30, 2)
    
    uuidref = property(__uuidref.value, __uuidref.set, None, None)

    
    # Attribute {http://www.isotc211.org/2005/gco}nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gco, 'nilReason'), 'nilReason', '__httpwww_isotc211_org2005gmd_MD_SecurityConstraints_PropertyType_httpwww_isotc211_org2005gconilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 33, 1)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/constraints.xsd', 84, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}type uses Python identifier type
    __type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'type'), 'type', '__httpwww_isotc211_org2005gmd_MD_SecurityConstraints_PropertyType_httpwww_w3_org1999xlinktype', _ImportedBinding_bindings_v1411_write__xlink.typeType, fixed=True, unicode_default='simple')
    __type._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 29, 1)
    __type._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 112, 2)
    
    type = property(__type.value, __type.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}href uses Python identifier href
    __href = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'href'), 'href', '__httpwww_isotc211_org2005gmd_MD_SecurityConstraints_PropertyType_httpwww_w3_org1999xlinkhref', _ImportedBinding_bindings_v1411_write__xlink.hrefType)
    __href._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 42, 1)
    __href._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 113, 2)
    
    href = property(__href.value, __href.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}role uses Python identifier role
    __role = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'role'), 'role', '__httpwww_isotc211_org2005gmd_MD_SecurityConstraints_PropertyType_httpwww_w3_org1999xlinkrole', _ImportedBinding_bindings_v1411_write__xlink.roleType)
    __role._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 48, 1)
    __role._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 114, 2)
    
    role = property(__role.value, __role.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}arcrole uses Python identifier arcrole
    __arcrole = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'arcrole'), 'arcrole', '__httpwww_isotc211_org2005gmd_MD_SecurityConstraints_PropertyType_httpwww_w3_org1999xlinkarcrole', _ImportedBinding_bindings_v1411_write__xlink.arcroleType)
    __arcrole._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 56, 1)
    __arcrole._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 115, 2)
    
    arcrole = property(__arcrole.value, __arcrole.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}title uses Python identifier title
    __title = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'title'), 'title', '__httpwww_isotc211_org2005gmd_MD_SecurityConstraints_PropertyType_httpwww_w3_org1999xlinktitle', _ImportedBinding_bindings_v1411_write__xlink.titleAttrType)
    __title._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 64, 1)
    __title._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 116, 2)
    
    title = property(__title.value, __title.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}show uses Python identifier show
    __show = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'show'), 'show', '__httpwww_isotc211_org2005gmd_MD_SecurityConstraints_PropertyType_httpwww_w3_org1999xlinkshow', _ImportedBinding_bindings_v1411_write__xlink.showType)
    __show._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 70, 1)
    __show._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 117, 2)
    
    show = property(__show.value, __show.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}actuate uses Python identifier actuate
    __actuate = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'actuate'), 'actuate', '__httpwww_isotc211_org2005gmd_MD_SecurityConstraints_PropertyType_httpwww_w3_org1999xlinkactuate', _ImportedBinding_bindings_v1411_write__xlink.actuateType)
    __actuate._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 82, 1)
    __actuate._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 118, 2)
    
    actuate = property(__actuate.value, __actuate.set, None, None)

    _ElementMap.update({
        __MD_SecurityConstraints.name() : __MD_SecurityConstraints
    })
    _AttributeMap.update({
        __uuidref.name() : __uuidref,
        __nilReason.name() : __nilReason,
        __type.name() : __type,
        __href.name() : __href,
        __role.name() : __role,
        __arcrole.name() : __arcrole,
        __title.name() : __title,
        __show.name() : __show,
        __actuate.name() : __actuate
    })
_module_typeBindings.MD_SecurityConstraints_PropertyType = MD_SecurityConstraints_PropertyType
_Namespace_gmd.addCategoryObject('typeBinding', 'MD_SecurityConstraints_PropertyType', MD_SecurityConstraints_PropertyType)


# Complex type {http://www.isotc211.org/2005/gmd}MD_ClassificationCode_PropertyType with content type ELEMENT_ONLY
class MD_ClassificationCode_PropertyType (pyxb.binding.basis.complexTypeDefinition):
    """Complex type {http://www.isotc211.org/2005/gmd}MD_ClassificationCode_PropertyType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_ClassificationCode_PropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/constraints.xsd', 90, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.isotc211.org/2005/gmd}MD_ClassificationCode uses Python identifier MD_ClassificationCode
    __MD_ClassificationCode = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_ClassificationCode'), 'MD_ClassificationCode', '__httpwww_isotc211_org2005gmd_MD_ClassificationCode_PropertyType_httpwww_isotc211_org2005gmdMD_ClassificationCode', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/constraints.xsd', 88, 1), )

    
    MD_ClassificationCode = property(__MD_ClassificationCode.value, __MD_ClassificationCode.set, None, None)

    
    # Attribute {http://www.isotc211.org/2005/gco}nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gco, 'nilReason'), 'nilReason', '__httpwww_isotc211_org2005gmd_MD_ClassificationCode_PropertyType_httpwww_isotc211_org2005gconilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 33, 1)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/constraints.xsd', 94, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    _ElementMap.update({
        __MD_ClassificationCode.name() : __MD_ClassificationCode
    })
    _AttributeMap.update({
        __nilReason.name() : __nilReason
    })
_module_typeBindings.MD_ClassificationCode_PropertyType = MD_ClassificationCode_PropertyType
_Namespace_gmd.addCategoryObject('typeBinding', 'MD_ClassificationCode_PropertyType', MD_ClassificationCode_PropertyType)


# Complex type {http://www.isotc211.org/2005/gmd}MD_RestrictionCode_PropertyType with content type ELEMENT_ONLY
class MD_RestrictionCode_PropertyType (pyxb.binding.basis.complexTypeDefinition):
    """Complex type {http://www.isotc211.org/2005/gmd}MD_RestrictionCode_PropertyType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_RestrictionCode_PropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/constraints.xsd', 100, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.isotc211.org/2005/gmd}MD_RestrictionCode uses Python identifier MD_RestrictionCode
    __MD_RestrictionCode = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_RestrictionCode'), 'MD_RestrictionCode', '__httpwww_isotc211_org2005gmd_MD_RestrictionCode_PropertyType_httpwww_isotc211_org2005gmdMD_RestrictionCode', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/constraints.xsd', 98, 1), )

    
    MD_RestrictionCode = property(__MD_RestrictionCode.value, __MD_RestrictionCode.set, None, None)

    
    # Attribute {http://www.isotc211.org/2005/gco}nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gco, 'nilReason'), 'nilReason', '__httpwww_isotc211_org2005gmd_MD_RestrictionCode_PropertyType_httpwww_isotc211_org2005gconilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 33, 1)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/constraints.xsd', 104, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    _ElementMap.update({
        __MD_RestrictionCode.name() : __MD_RestrictionCode
    })
    _AttributeMap.update({
        __nilReason.name() : __nilReason
    })
_module_typeBindings.MD_RestrictionCode_PropertyType = MD_RestrictionCode_PropertyType
_Namespace_gmd.addCategoryObject('typeBinding', 'MD_RestrictionCode_PropertyType', MD_RestrictionCode_PropertyType)


# Complex type {http://www.isotc211.org/2005/gmd}MD_FeatureCatalogueDescription_Type with content type ELEMENT_ONLY
class MD_FeatureCatalogueDescription_Type (AbstractMD_ContentInformation_Type):
    """Information identifing the feature catalogue"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_FeatureCatalogueDescription_Type')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/content.xsd', 15, 1)
    _ElementMap = AbstractMD_ContentInformation_Type._ElementMap.copy()
    _AttributeMap = AbstractMD_ContentInformation_Type._AttributeMap.copy()
    # Base type is AbstractMD_ContentInformation_Type
    
    # Element {http://www.isotc211.org/2005/gmd}complianceCode uses Python identifier complianceCode
    __complianceCode = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'complianceCode'), 'complianceCode', '__httpwww_isotc211_org2005gmd_MD_FeatureCatalogueDescription_Type_httpwww_isotc211_org2005gmdcomplianceCode', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/content.xsd', 22, 5), )

    
    complianceCode = property(__complianceCode.value, __complianceCode.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}language uses Python identifier language
    __language = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'language'), 'language', '__httpwww_isotc211_org2005gmd_MD_FeatureCatalogueDescription_Type_httpwww_isotc211_org2005gmdlanguage', True, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/content.xsd', 23, 5), )

    
    language = property(__language.value, __language.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}includedWithDataset uses Python identifier includedWithDataset
    __includedWithDataset = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'includedWithDataset'), 'includedWithDataset', '__httpwww_isotc211_org2005gmd_MD_FeatureCatalogueDescription_Type_httpwww_isotc211_org2005gmdincludedWithDataset', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/content.xsd', 24, 5), )

    
    includedWithDataset = property(__includedWithDataset.value, __includedWithDataset.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}featureTypes uses Python identifier featureTypes
    __featureTypes = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'featureTypes'), 'featureTypes', '__httpwww_isotc211_org2005gmd_MD_FeatureCatalogueDescription_Type_httpwww_isotc211_org2005gmdfeatureTypes', True, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/content.xsd', 25, 5), )

    
    featureTypes = property(__featureTypes.value, __featureTypes.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}featureCatalogueCitation uses Python identifier featureCatalogueCitation
    __featureCatalogueCitation = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'featureCatalogueCitation'), 'featureCatalogueCitation', '__httpwww_isotc211_org2005gmd_MD_FeatureCatalogueDescription_Type_httpwww_isotc211_org2005gmdfeatureCatalogueCitation', True, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/content.xsd', 26, 5), )

    
    featureCatalogueCitation = property(__featureCatalogueCitation.value, __featureCatalogueCitation.set, None, None)

    
    # Attribute id inherited from {http://www.isotc211.org/2005/gco}AbstractObject_Type
    
    # Attribute uuid inherited from {http://www.isotc211.org/2005/gco}AbstractObject_Type
    _ElementMap.update({
        __complianceCode.name() : __complianceCode,
        __language.name() : __language,
        __includedWithDataset.name() : __includedWithDataset,
        __featureTypes.name() : __featureTypes,
        __featureCatalogueCitation.name() : __featureCatalogueCitation
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.MD_FeatureCatalogueDescription_Type = MD_FeatureCatalogueDescription_Type
_Namespace_gmd.addCategoryObject('typeBinding', 'MD_FeatureCatalogueDescription_Type', MD_FeatureCatalogueDescription_Type)


# Complex type {http://www.isotc211.org/2005/gmd}MD_FeatureCatalogueDescription_PropertyType with content type ELEMENT_ONLY
class MD_FeatureCatalogueDescription_PropertyType (pyxb.binding.basis.complexTypeDefinition):
    """Complex type {http://www.isotc211.org/2005/gmd}MD_FeatureCatalogueDescription_PropertyType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_FeatureCatalogueDescription_PropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/content.xsd', 34, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.isotc211.org/2005/gmd}MD_FeatureCatalogueDescription uses Python identifier MD_FeatureCatalogueDescription
    __MD_FeatureCatalogueDescription = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_FeatureCatalogueDescription'), 'MD_FeatureCatalogueDescription', '__httpwww_isotc211_org2005gmd_MD_FeatureCatalogueDescription_PropertyType_httpwww_isotc211_org2005gmdMD_FeatureCatalogueDescription', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/content.xsd', 32, 1), )

    
    MD_FeatureCatalogueDescription = property(__MD_FeatureCatalogueDescription.value, __MD_FeatureCatalogueDescription.set, None, None)

    
    # Attribute uuidref uses Python identifier uuidref
    __uuidref = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'uuidref'), 'uuidref', '__httpwww_isotc211_org2005gmd_MD_FeatureCatalogueDescription_PropertyType_uuidref', pyxb.binding.datatypes.string)
    __uuidref._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 30, 2)
    __uuidref._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 30, 2)
    
    uuidref = property(__uuidref.value, __uuidref.set, None, None)

    
    # Attribute {http://www.isotc211.org/2005/gco}nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gco, 'nilReason'), 'nilReason', '__httpwww_isotc211_org2005gmd_MD_FeatureCatalogueDescription_PropertyType_httpwww_isotc211_org2005gconilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 33, 1)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/content.xsd', 39, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}type uses Python identifier type
    __type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'type'), 'type', '__httpwww_isotc211_org2005gmd_MD_FeatureCatalogueDescription_PropertyType_httpwww_w3_org1999xlinktype', _ImportedBinding_bindings_v1411_write__xlink.typeType, fixed=True, unicode_default='simple')
    __type._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 29, 1)
    __type._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 112, 2)
    
    type = property(__type.value, __type.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}href uses Python identifier href
    __href = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'href'), 'href', '__httpwww_isotc211_org2005gmd_MD_FeatureCatalogueDescription_PropertyType_httpwww_w3_org1999xlinkhref', _ImportedBinding_bindings_v1411_write__xlink.hrefType)
    __href._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 42, 1)
    __href._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 113, 2)
    
    href = property(__href.value, __href.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}role uses Python identifier role
    __role = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'role'), 'role', '__httpwww_isotc211_org2005gmd_MD_FeatureCatalogueDescription_PropertyType_httpwww_w3_org1999xlinkrole', _ImportedBinding_bindings_v1411_write__xlink.roleType)
    __role._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 48, 1)
    __role._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 114, 2)
    
    role = property(__role.value, __role.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}arcrole uses Python identifier arcrole
    __arcrole = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'arcrole'), 'arcrole', '__httpwww_isotc211_org2005gmd_MD_FeatureCatalogueDescription_PropertyType_httpwww_w3_org1999xlinkarcrole', _ImportedBinding_bindings_v1411_write__xlink.arcroleType)
    __arcrole._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 56, 1)
    __arcrole._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 115, 2)
    
    arcrole = property(__arcrole.value, __arcrole.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}title uses Python identifier title
    __title = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'title'), 'title', '__httpwww_isotc211_org2005gmd_MD_FeatureCatalogueDescription_PropertyType_httpwww_w3_org1999xlinktitle', _ImportedBinding_bindings_v1411_write__xlink.titleAttrType)
    __title._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 64, 1)
    __title._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 116, 2)
    
    title = property(__title.value, __title.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}show uses Python identifier show
    __show = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'show'), 'show', '__httpwww_isotc211_org2005gmd_MD_FeatureCatalogueDescription_PropertyType_httpwww_w3_org1999xlinkshow', _ImportedBinding_bindings_v1411_write__xlink.showType)
    __show._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 70, 1)
    __show._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 117, 2)
    
    show = property(__show.value, __show.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}actuate uses Python identifier actuate
    __actuate = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'actuate'), 'actuate', '__httpwww_isotc211_org2005gmd_MD_FeatureCatalogueDescription_PropertyType_httpwww_w3_org1999xlinkactuate', _ImportedBinding_bindings_v1411_write__xlink.actuateType)
    __actuate._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 82, 1)
    __actuate._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 118, 2)
    
    actuate = property(__actuate.value, __actuate.set, None, None)

    _ElementMap.update({
        __MD_FeatureCatalogueDescription.name() : __MD_FeatureCatalogueDescription
    })
    _AttributeMap.update({
        __uuidref.name() : __uuidref,
        __nilReason.name() : __nilReason,
        __type.name() : __type,
        __href.name() : __href,
        __role.name() : __role,
        __arcrole.name() : __arcrole,
        __title.name() : __title,
        __show.name() : __show,
        __actuate.name() : __actuate
    })
_module_typeBindings.MD_FeatureCatalogueDescription_PropertyType = MD_FeatureCatalogueDescription_PropertyType
_Namespace_gmd.addCategoryObject('typeBinding', 'MD_FeatureCatalogueDescription_PropertyType', MD_FeatureCatalogueDescription_PropertyType)


# Complex type {http://www.isotc211.org/2005/gmd}MD_CoverageDescription_Type with content type ELEMENT_ONLY
class MD_CoverageDescription_Type (AbstractMD_ContentInformation_Type):
    """Information about the domain of the raster cell"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_CoverageDescription_Type')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/content.xsd', 42, 1)
    _ElementMap = AbstractMD_ContentInformation_Type._ElementMap.copy()
    _AttributeMap = AbstractMD_ContentInformation_Type._AttributeMap.copy()
    # Base type is AbstractMD_ContentInformation_Type
    
    # Element {http://www.isotc211.org/2005/gmd}attributeDescription uses Python identifier attributeDescription
    __attributeDescription = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'attributeDescription'), 'attributeDescription', '__httpwww_isotc211_org2005gmd_MD_CoverageDescription_Type_httpwww_isotc211_org2005gmdattributeDescription', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/content.xsd', 49, 5), )

    
    attributeDescription = property(__attributeDescription.value, __attributeDescription.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}contentType uses Python identifier contentType
    __contentType = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'contentType'), 'contentType', '__httpwww_isotc211_org2005gmd_MD_CoverageDescription_Type_httpwww_isotc211_org2005gmdcontentType', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/content.xsd', 50, 5), )

    
    contentType = property(__contentType.value, __contentType.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}dimension uses Python identifier dimension
    __dimension = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'dimension'), 'dimension', '__httpwww_isotc211_org2005gmd_MD_CoverageDescription_Type_httpwww_isotc211_org2005gmddimension', True, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/content.xsd', 51, 5), )

    
    dimension = property(__dimension.value, __dimension.set, None, None)

    
    # Attribute id inherited from {http://www.isotc211.org/2005/gco}AbstractObject_Type
    
    # Attribute uuid inherited from {http://www.isotc211.org/2005/gco}AbstractObject_Type
    _ElementMap.update({
        __attributeDescription.name() : __attributeDescription,
        __contentType.name() : __contentType,
        __dimension.name() : __dimension
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.MD_CoverageDescription_Type = MD_CoverageDescription_Type
_Namespace_gmd.addCategoryObject('typeBinding', 'MD_CoverageDescription_Type', MD_CoverageDescription_Type)


# Complex type {http://www.isotc211.org/2005/gmd}MD_CoverageDescription_PropertyType with content type ELEMENT_ONLY
class MD_CoverageDescription_PropertyType (pyxb.binding.basis.complexTypeDefinition):
    """Complex type {http://www.isotc211.org/2005/gmd}MD_CoverageDescription_PropertyType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_CoverageDescription_PropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/content.xsd', 59, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.isotc211.org/2005/gmd}MD_CoverageDescription uses Python identifier MD_CoverageDescription
    __MD_CoverageDescription = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_CoverageDescription'), 'MD_CoverageDescription', '__httpwww_isotc211_org2005gmd_MD_CoverageDescription_PropertyType_httpwww_isotc211_org2005gmdMD_CoverageDescription', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/content.xsd', 57, 1), )

    
    MD_CoverageDescription = property(__MD_CoverageDescription.value, __MD_CoverageDescription.set, None, None)

    
    # Attribute uuidref uses Python identifier uuidref
    __uuidref = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'uuidref'), 'uuidref', '__httpwww_isotc211_org2005gmd_MD_CoverageDescription_PropertyType_uuidref', pyxb.binding.datatypes.string)
    __uuidref._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 30, 2)
    __uuidref._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 30, 2)
    
    uuidref = property(__uuidref.value, __uuidref.set, None, None)

    
    # Attribute {http://www.isotc211.org/2005/gco}nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gco, 'nilReason'), 'nilReason', '__httpwww_isotc211_org2005gmd_MD_CoverageDescription_PropertyType_httpwww_isotc211_org2005gconilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 33, 1)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/content.xsd', 64, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}type uses Python identifier type
    __type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'type'), 'type', '__httpwww_isotc211_org2005gmd_MD_CoverageDescription_PropertyType_httpwww_w3_org1999xlinktype', _ImportedBinding_bindings_v1411_write__xlink.typeType, fixed=True, unicode_default='simple')
    __type._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 29, 1)
    __type._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 112, 2)
    
    type = property(__type.value, __type.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}href uses Python identifier href
    __href = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'href'), 'href', '__httpwww_isotc211_org2005gmd_MD_CoverageDescription_PropertyType_httpwww_w3_org1999xlinkhref', _ImportedBinding_bindings_v1411_write__xlink.hrefType)
    __href._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 42, 1)
    __href._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 113, 2)
    
    href = property(__href.value, __href.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}role uses Python identifier role
    __role = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'role'), 'role', '__httpwww_isotc211_org2005gmd_MD_CoverageDescription_PropertyType_httpwww_w3_org1999xlinkrole', _ImportedBinding_bindings_v1411_write__xlink.roleType)
    __role._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 48, 1)
    __role._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 114, 2)
    
    role = property(__role.value, __role.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}arcrole uses Python identifier arcrole
    __arcrole = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'arcrole'), 'arcrole', '__httpwww_isotc211_org2005gmd_MD_CoverageDescription_PropertyType_httpwww_w3_org1999xlinkarcrole', _ImportedBinding_bindings_v1411_write__xlink.arcroleType)
    __arcrole._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 56, 1)
    __arcrole._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 115, 2)
    
    arcrole = property(__arcrole.value, __arcrole.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}title uses Python identifier title
    __title = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'title'), 'title', '__httpwww_isotc211_org2005gmd_MD_CoverageDescription_PropertyType_httpwww_w3_org1999xlinktitle', _ImportedBinding_bindings_v1411_write__xlink.titleAttrType)
    __title._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 64, 1)
    __title._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 116, 2)
    
    title = property(__title.value, __title.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}show uses Python identifier show
    __show = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'show'), 'show', '__httpwww_isotc211_org2005gmd_MD_CoverageDescription_PropertyType_httpwww_w3_org1999xlinkshow', _ImportedBinding_bindings_v1411_write__xlink.showType)
    __show._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 70, 1)
    __show._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 117, 2)
    
    show = property(__show.value, __show.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}actuate uses Python identifier actuate
    __actuate = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'actuate'), 'actuate', '__httpwww_isotc211_org2005gmd_MD_CoverageDescription_PropertyType_httpwww_w3_org1999xlinkactuate', _ImportedBinding_bindings_v1411_write__xlink.actuateType)
    __actuate._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 82, 1)
    __actuate._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 118, 2)
    
    actuate = property(__actuate.value, __actuate.set, None, None)

    _ElementMap.update({
        __MD_CoverageDescription.name() : __MD_CoverageDescription
    })
    _AttributeMap.update({
        __uuidref.name() : __uuidref,
        __nilReason.name() : __nilReason,
        __type.name() : __type,
        __href.name() : __href,
        __role.name() : __role,
        __arcrole.name() : __arcrole,
        __title.name() : __title,
        __show.name() : __show,
        __actuate.name() : __actuate
    })
_module_typeBindings.MD_CoverageDescription_PropertyType = MD_CoverageDescription_PropertyType
_Namespace_gmd.addCategoryObject('typeBinding', 'MD_CoverageDescription_PropertyType', MD_CoverageDescription_PropertyType)


# Complex type {http://www.isotc211.org/2005/gmd}MD_ImageDescription_PropertyType with content type ELEMENT_ONLY
class MD_ImageDescription_PropertyType (pyxb.binding.basis.complexTypeDefinition):
    """Complex type {http://www.isotc211.org/2005/gmd}MD_ImageDescription_PropertyType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_ImageDescription_PropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/content.xsd', 93, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.isotc211.org/2005/gmd}MD_ImageDescription uses Python identifier MD_ImageDescription
    __MD_ImageDescription = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_ImageDescription'), 'MD_ImageDescription', '__httpwww_isotc211_org2005gmd_MD_ImageDescription_PropertyType_httpwww_isotc211_org2005gmdMD_ImageDescription', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/content.xsd', 91, 1), )

    
    MD_ImageDescription = property(__MD_ImageDescription.value, __MD_ImageDescription.set, None, None)

    
    # Attribute uuidref uses Python identifier uuidref
    __uuidref = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'uuidref'), 'uuidref', '__httpwww_isotc211_org2005gmd_MD_ImageDescription_PropertyType_uuidref', pyxb.binding.datatypes.string)
    __uuidref._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 30, 2)
    __uuidref._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 30, 2)
    
    uuidref = property(__uuidref.value, __uuidref.set, None, None)

    
    # Attribute {http://www.isotc211.org/2005/gco}nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gco, 'nilReason'), 'nilReason', '__httpwww_isotc211_org2005gmd_MD_ImageDescription_PropertyType_httpwww_isotc211_org2005gconilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 33, 1)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/content.xsd', 98, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}type uses Python identifier type
    __type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'type'), 'type', '__httpwww_isotc211_org2005gmd_MD_ImageDescription_PropertyType_httpwww_w3_org1999xlinktype', _ImportedBinding_bindings_v1411_write__xlink.typeType, fixed=True, unicode_default='simple')
    __type._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 29, 1)
    __type._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 112, 2)
    
    type = property(__type.value, __type.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}href uses Python identifier href
    __href = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'href'), 'href', '__httpwww_isotc211_org2005gmd_MD_ImageDescription_PropertyType_httpwww_w3_org1999xlinkhref', _ImportedBinding_bindings_v1411_write__xlink.hrefType)
    __href._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 42, 1)
    __href._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 113, 2)
    
    href = property(__href.value, __href.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}role uses Python identifier role
    __role = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'role'), 'role', '__httpwww_isotc211_org2005gmd_MD_ImageDescription_PropertyType_httpwww_w3_org1999xlinkrole', _ImportedBinding_bindings_v1411_write__xlink.roleType)
    __role._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 48, 1)
    __role._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 114, 2)
    
    role = property(__role.value, __role.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}arcrole uses Python identifier arcrole
    __arcrole = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'arcrole'), 'arcrole', '__httpwww_isotc211_org2005gmd_MD_ImageDescription_PropertyType_httpwww_w3_org1999xlinkarcrole', _ImportedBinding_bindings_v1411_write__xlink.arcroleType)
    __arcrole._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 56, 1)
    __arcrole._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 115, 2)
    
    arcrole = property(__arcrole.value, __arcrole.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}title uses Python identifier title
    __title = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'title'), 'title', '__httpwww_isotc211_org2005gmd_MD_ImageDescription_PropertyType_httpwww_w3_org1999xlinktitle', _ImportedBinding_bindings_v1411_write__xlink.titleAttrType)
    __title._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 64, 1)
    __title._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 116, 2)
    
    title = property(__title.value, __title.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}show uses Python identifier show
    __show = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'show'), 'show', '__httpwww_isotc211_org2005gmd_MD_ImageDescription_PropertyType_httpwww_w3_org1999xlinkshow', _ImportedBinding_bindings_v1411_write__xlink.showType)
    __show._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 70, 1)
    __show._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 117, 2)
    
    show = property(__show.value, __show.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}actuate uses Python identifier actuate
    __actuate = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'actuate'), 'actuate', '__httpwww_isotc211_org2005gmd_MD_ImageDescription_PropertyType_httpwww_w3_org1999xlinkactuate', _ImportedBinding_bindings_v1411_write__xlink.actuateType)
    __actuate._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 82, 1)
    __actuate._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 118, 2)
    
    actuate = property(__actuate.value, __actuate.set, None, None)

    _ElementMap.update({
        __MD_ImageDescription.name() : __MD_ImageDescription
    })
    _AttributeMap.update({
        __uuidref.name() : __uuidref,
        __nilReason.name() : __nilReason,
        __type.name() : __type,
        __href.name() : __href,
        __role.name() : __role,
        __arcrole.name() : __arcrole,
        __title.name() : __title,
        __show.name() : __show,
        __actuate.name() : __actuate
    })
_module_typeBindings.MD_ImageDescription_PropertyType = MD_ImageDescription_PropertyType
_Namespace_gmd.addCategoryObject('typeBinding', 'MD_ImageDescription_PropertyType', MD_ImageDescription_PropertyType)


# Complex type {http://www.isotc211.org/2005/gmd}MD_ContentInformation_PropertyType with content type ELEMENT_ONLY
class MD_ContentInformation_PropertyType (pyxb.binding.basis.complexTypeDefinition):
    """Complex type {http://www.isotc211.org/2005/gmd}MD_ContentInformation_PropertyType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_ContentInformation_PropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/content.xsd', 111, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.isotc211.org/2005/gmd}AbstractMD_ContentInformation uses Python identifier AbstractMD_ContentInformation
    __AbstractMD_ContentInformation = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'AbstractMD_ContentInformation'), 'AbstractMD_ContentInformation', '__httpwww_isotc211_org2005gmd_MD_ContentInformation_PropertyType_httpwww_isotc211_org2005gmdAbstractMD_ContentInformation', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/content.xsd', 109, 1), )

    
    AbstractMD_ContentInformation = property(__AbstractMD_ContentInformation.value, __AbstractMD_ContentInformation.set, None, None)

    
    # Attribute uuidref uses Python identifier uuidref
    __uuidref = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'uuidref'), 'uuidref', '__httpwww_isotc211_org2005gmd_MD_ContentInformation_PropertyType_uuidref', pyxb.binding.datatypes.string)
    __uuidref._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 30, 2)
    __uuidref._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 30, 2)
    
    uuidref = property(__uuidref.value, __uuidref.set, None, None)

    
    # Attribute {http://www.isotc211.org/2005/gco}nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gco, 'nilReason'), 'nilReason', '__httpwww_isotc211_org2005gmd_MD_ContentInformation_PropertyType_httpwww_isotc211_org2005gconilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 33, 1)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/content.xsd', 116, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}type uses Python identifier type
    __type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'type'), 'type', '__httpwww_isotc211_org2005gmd_MD_ContentInformation_PropertyType_httpwww_w3_org1999xlinktype', _ImportedBinding_bindings_v1411_write__xlink.typeType, fixed=True, unicode_default='simple')
    __type._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 29, 1)
    __type._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 112, 2)
    
    type = property(__type.value, __type.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}href uses Python identifier href
    __href = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'href'), 'href', '__httpwww_isotc211_org2005gmd_MD_ContentInformation_PropertyType_httpwww_w3_org1999xlinkhref', _ImportedBinding_bindings_v1411_write__xlink.hrefType)
    __href._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 42, 1)
    __href._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 113, 2)
    
    href = property(__href.value, __href.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}role uses Python identifier role
    __role = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'role'), 'role', '__httpwww_isotc211_org2005gmd_MD_ContentInformation_PropertyType_httpwww_w3_org1999xlinkrole', _ImportedBinding_bindings_v1411_write__xlink.roleType)
    __role._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 48, 1)
    __role._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 114, 2)
    
    role = property(__role.value, __role.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}arcrole uses Python identifier arcrole
    __arcrole = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'arcrole'), 'arcrole', '__httpwww_isotc211_org2005gmd_MD_ContentInformation_PropertyType_httpwww_w3_org1999xlinkarcrole', _ImportedBinding_bindings_v1411_write__xlink.arcroleType)
    __arcrole._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 56, 1)
    __arcrole._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 115, 2)
    
    arcrole = property(__arcrole.value, __arcrole.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}title uses Python identifier title
    __title = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'title'), 'title', '__httpwww_isotc211_org2005gmd_MD_ContentInformation_PropertyType_httpwww_w3_org1999xlinktitle', _ImportedBinding_bindings_v1411_write__xlink.titleAttrType)
    __title._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 64, 1)
    __title._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 116, 2)
    
    title = property(__title.value, __title.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}show uses Python identifier show
    __show = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'show'), 'show', '__httpwww_isotc211_org2005gmd_MD_ContentInformation_PropertyType_httpwww_w3_org1999xlinkshow', _ImportedBinding_bindings_v1411_write__xlink.showType)
    __show._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 70, 1)
    __show._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 117, 2)
    
    show = property(__show.value, __show.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}actuate uses Python identifier actuate
    __actuate = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'actuate'), 'actuate', '__httpwww_isotc211_org2005gmd_MD_ContentInformation_PropertyType_httpwww_w3_org1999xlinkactuate', _ImportedBinding_bindings_v1411_write__xlink.actuateType)
    __actuate._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 82, 1)
    __actuate._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 118, 2)
    
    actuate = property(__actuate.value, __actuate.set, None, None)

    _ElementMap.update({
        __AbstractMD_ContentInformation.name() : __AbstractMD_ContentInformation
    })
    _AttributeMap.update({
        __uuidref.name() : __uuidref,
        __nilReason.name() : __nilReason,
        __type.name() : __type,
        __href.name() : __href,
        __role.name() : __role,
        __arcrole.name() : __arcrole,
        __title.name() : __title,
        __show.name() : __show,
        __actuate.name() : __actuate
    })
_module_typeBindings.MD_ContentInformation_PropertyType = MD_ContentInformation_PropertyType
_Namespace_gmd.addCategoryObject('typeBinding', 'MD_ContentInformation_PropertyType', MD_ContentInformation_PropertyType)


# Complex type {http://www.isotc211.org/2005/gmd}MD_RangeDimension_PropertyType with content type ELEMENT_ONLY
class MD_RangeDimension_PropertyType (pyxb.binding.basis.complexTypeDefinition):
    """Complex type {http://www.isotc211.org/2005/gmd}MD_RangeDimension_PropertyType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_RangeDimension_PropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/content.xsd', 135, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.isotc211.org/2005/gmd}MD_RangeDimension uses Python identifier MD_RangeDimension
    __MD_RangeDimension = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_RangeDimension'), 'MD_RangeDimension', '__httpwww_isotc211_org2005gmd_MD_RangeDimension_PropertyType_httpwww_isotc211_org2005gmdMD_RangeDimension', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/content.xsd', 133, 1), )

    
    MD_RangeDimension = property(__MD_RangeDimension.value, __MD_RangeDimension.set, None, None)

    
    # Attribute uuidref uses Python identifier uuidref
    __uuidref = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'uuidref'), 'uuidref', '__httpwww_isotc211_org2005gmd_MD_RangeDimension_PropertyType_uuidref', pyxb.binding.datatypes.string)
    __uuidref._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 30, 2)
    __uuidref._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 30, 2)
    
    uuidref = property(__uuidref.value, __uuidref.set, None, None)

    
    # Attribute {http://www.isotc211.org/2005/gco}nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gco, 'nilReason'), 'nilReason', '__httpwww_isotc211_org2005gmd_MD_RangeDimension_PropertyType_httpwww_isotc211_org2005gconilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 33, 1)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/content.xsd', 140, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}type uses Python identifier type
    __type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'type'), 'type', '__httpwww_isotc211_org2005gmd_MD_RangeDimension_PropertyType_httpwww_w3_org1999xlinktype', _ImportedBinding_bindings_v1411_write__xlink.typeType, fixed=True, unicode_default='simple')
    __type._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 29, 1)
    __type._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 112, 2)
    
    type = property(__type.value, __type.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}href uses Python identifier href
    __href = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'href'), 'href', '__httpwww_isotc211_org2005gmd_MD_RangeDimension_PropertyType_httpwww_w3_org1999xlinkhref', _ImportedBinding_bindings_v1411_write__xlink.hrefType)
    __href._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 42, 1)
    __href._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 113, 2)
    
    href = property(__href.value, __href.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}role uses Python identifier role
    __role = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'role'), 'role', '__httpwww_isotc211_org2005gmd_MD_RangeDimension_PropertyType_httpwww_w3_org1999xlinkrole', _ImportedBinding_bindings_v1411_write__xlink.roleType)
    __role._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 48, 1)
    __role._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 114, 2)
    
    role = property(__role.value, __role.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}arcrole uses Python identifier arcrole
    __arcrole = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'arcrole'), 'arcrole', '__httpwww_isotc211_org2005gmd_MD_RangeDimension_PropertyType_httpwww_w3_org1999xlinkarcrole', _ImportedBinding_bindings_v1411_write__xlink.arcroleType)
    __arcrole._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 56, 1)
    __arcrole._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 115, 2)
    
    arcrole = property(__arcrole.value, __arcrole.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}title uses Python identifier title
    __title = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'title'), 'title', '__httpwww_isotc211_org2005gmd_MD_RangeDimension_PropertyType_httpwww_w3_org1999xlinktitle', _ImportedBinding_bindings_v1411_write__xlink.titleAttrType)
    __title._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 64, 1)
    __title._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 116, 2)
    
    title = property(__title.value, __title.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}show uses Python identifier show
    __show = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'show'), 'show', '__httpwww_isotc211_org2005gmd_MD_RangeDimension_PropertyType_httpwww_w3_org1999xlinkshow', _ImportedBinding_bindings_v1411_write__xlink.showType)
    __show._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 70, 1)
    __show._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 117, 2)
    
    show = property(__show.value, __show.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}actuate uses Python identifier actuate
    __actuate = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'actuate'), 'actuate', '__httpwww_isotc211_org2005gmd_MD_RangeDimension_PropertyType_httpwww_w3_org1999xlinkactuate', _ImportedBinding_bindings_v1411_write__xlink.actuateType)
    __actuate._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 82, 1)
    __actuate._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 118, 2)
    
    actuate = property(__actuate.value, __actuate.set, None, None)

    _ElementMap.update({
        __MD_RangeDimension.name() : __MD_RangeDimension
    })
    _AttributeMap.update({
        __uuidref.name() : __uuidref,
        __nilReason.name() : __nilReason,
        __type.name() : __type,
        __href.name() : __href,
        __role.name() : __role,
        __arcrole.name() : __arcrole,
        __title.name() : __title,
        __show.name() : __show,
        __actuate.name() : __actuate
    })
_module_typeBindings.MD_RangeDimension_PropertyType = MD_RangeDimension_PropertyType
_Namespace_gmd.addCategoryObject('typeBinding', 'MD_RangeDimension_PropertyType', MD_RangeDimension_PropertyType)


# Complex type {http://www.isotc211.org/2005/gmd}MD_Band_Type with content type ELEMENT_ONLY
class MD_Band_Type (MD_RangeDimension_Type):
    """Complex type {http://www.isotc211.org/2005/gmd}MD_Band_Type with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_Band_Type')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/content.xsd', 143, 1)
    _ElementMap = MD_RangeDimension_Type._ElementMap.copy()
    _AttributeMap = MD_RangeDimension_Type._AttributeMap.copy()
    # Base type is MD_RangeDimension_Type
    
    # Element sequenceIdentifier ({http://www.isotc211.org/2005/gmd}sequenceIdentifier) inherited from {http://www.isotc211.org/2005/gmd}MD_RangeDimension_Type
    
    # Element descriptor ({http://www.isotc211.org/2005/gmd}descriptor) inherited from {http://www.isotc211.org/2005/gmd}MD_RangeDimension_Type
    
    # Element {http://www.isotc211.org/2005/gmd}maxValue uses Python identifier maxValue
    __maxValue = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'maxValue'), 'maxValue', '__httpwww_isotc211_org2005gmd_MD_Band_Type_httpwww_isotc211_org2005gmdmaxValue', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/content.xsd', 147, 5), )

    
    maxValue = property(__maxValue.value, __maxValue.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}minValue uses Python identifier minValue
    __minValue = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'minValue'), 'minValue', '__httpwww_isotc211_org2005gmd_MD_Band_Type_httpwww_isotc211_org2005gmdminValue', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/content.xsd', 148, 5), )

    
    minValue = property(__minValue.value, __minValue.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}units uses Python identifier units
    __units = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'units'), 'units', '__httpwww_isotc211_org2005gmd_MD_Band_Type_httpwww_isotc211_org2005gmdunits', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/content.xsd', 149, 5), )

    
    units = property(__units.value, __units.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}peakResponse uses Python identifier peakResponse
    __peakResponse = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'peakResponse'), 'peakResponse', '__httpwww_isotc211_org2005gmd_MD_Band_Type_httpwww_isotc211_org2005gmdpeakResponse', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/content.xsd', 150, 5), )

    
    peakResponse = property(__peakResponse.value, __peakResponse.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}bitsPerValue uses Python identifier bitsPerValue
    __bitsPerValue = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'bitsPerValue'), 'bitsPerValue', '__httpwww_isotc211_org2005gmd_MD_Band_Type_httpwww_isotc211_org2005gmdbitsPerValue', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/content.xsd', 151, 5), )

    
    bitsPerValue = property(__bitsPerValue.value, __bitsPerValue.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}toneGradation uses Python identifier toneGradation
    __toneGradation = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'toneGradation'), 'toneGradation', '__httpwww_isotc211_org2005gmd_MD_Band_Type_httpwww_isotc211_org2005gmdtoneGradation', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/content.xsd', 152, 5), )

    
    toneGradation = property(__toneGradation.value, __toneGradation.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}scaleFactor uses Python identifier scaleFactor
    __scaleFactor = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'scaleFactor'), 'scaleFactor', '__httpwww_isotc211_org2005gmd_MD_Band_Type_httpwww_isotc211_org2005gmdscaleFactor', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/content.xsd', 153, 5), )

    
    scaleFactor = property(__scaleFactor.value, __scaleFactor.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}offset uses Python identifier offset
    __offset = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'offset'), 'offset', '__httpwww_isotc211_org2005gmd_MD_Band_Type_httpwww_isotc211_org2005gmdoffset', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/content.xsd', 154, 5), )

    
    offset = property(__offset.value, __offset.set, None, None)

    
    # Attribute id inherited from {http://www.isotc211.org/2005/gco}AbstractObject_Type
    
    # Attribute uuid inherited from {http://www.isotc211.org/2005/gco}AbstractObject_Type
    _ElementMap.update({
        __maxValue.name() : __maxValue,
        __minValue.name() : __minValue,
        __units.name() : __units,
        __peakResponse.name() : __peakResponse,
        __bitsPerValue.name() : __bitsPerValue,
        __toneGradation.name() : __toneGradation,
        __scaleFactor.name() : __scaleFactor,
        __offset.name() : __offset
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.MD_Band_Type = MD_Band_Type
_Namespace_gmd.addCategoryObject('typeBinding', 'MD_Band_Type', MD_Band_Type)


# Complex type {http://www.isotc211.org/2005/gmd}MD_Band_PropertyType with content type ELEMENT_ONLY
class MD_Band_PropertyType (pyxb.binding.basis.complexTypeDefinition):
    """Complex type {http://www.isotc211.org/2005/gmd}MD_Band_PropertyType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_Band_PropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/content.xsd', 162, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.isotc211.org/2005/gmd}MD_Band uses Python identifier MD_Band
    __MD_Band = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_Band'), 'MD_Band', '__httpwww_isotc211_org2005gmd_MD_Band_PropertyType_httpwww_isotc211_org2005gmdMD_Band', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/content.xsd', 160, 1), )

    
    MD_Band = property(__MD_Band.value, __MD_Band.set, None, None)

    
    # Attribute uuidref uses Python identifier uuidref
    __uuidref = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'uuidref'), 'uuidref', '__httpwww_isotc211_org2005gmd_MD_Band_PropertyType_uuidref', pyxb.binding.datatypes.string)
    __uuidref._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 30, 2)
    __uuidref._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 30, 2)
    
    uuidref = property(__uuidref.value, __uuidref.set, None, None)

    
    # Attribute {http://www.isotc211.org/2005/gco}nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gco, 'nilReason'), 'nilReason', '__httpwww_isotc211_org2005gmd_MD_Band_PropertyType_httpwww_isotc211_org2005gconilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 33, 1)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/content.xsd', 167, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}type uses Python identifier type
    __type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'type'), 'type', '__httpwww_isotc211_org2005gmd_MD_Band_PropertyType_httpwww_w3_org1999xlinktype', _ImportedBinding_bindings_v1411_write__xlink.typeType, fixed=True, unicode_default='simple')
    __type._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 29, 1)
    __type._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 112, 2)
    
    type = property(__type.value, __type.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}href uses Python identifier href
    __href = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'href'), 'href', '__httpwww_isotc211_org2005gmd_MD_Band_PropertyType_httpwww_w3_org1999xlinkhref', _ImportedBinding_bindings_v1411_write__xlink.hrefType)
    __href._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 42, 1)
    __href._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 113, 2)
    
    href = property(__href.value, __href.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}role uses Python identifier role
    __role = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'role'), 'role', '__httpwww_isotc211_org2005gmd_MD_Band_PropertyType_httpwww_w3_org1999xlinkrole', _ImportedBinding_bindings_v1411_write__xlink.roleType)
    __role._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 48, 1)
    __role._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 114, 2)
    
    role = property(__role.value, __role.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}arcrole uses Python identifier arcrole
    __arcrole = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'arcrole'), 'arcrole', '__httpwww_isotc211_org2005gmd_MD_Band_PropertyType_httpwww_w3_org1999xlinkarcrole', _ImportedBinding_bindings_v1411_write__xlink.arcroleType)
    __arcrole._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 56, 1)
    __arcrole._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 115, 2)
    
    arcrole = property(__arcrole.value, __arcrole.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}title uses Python identifier title
    __title = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'title'), 'title', '__httpwww_isotc211_org2005gmd_MD_Band_PropertyType_httpwww_w3_org1999xlinktitle', _ImportedBinding_bindings_v1411_write__xlink.titleAttrType)
    __title._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 64, 1)
    __title._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 116, 2)
    
    title = property(__title.value, __title.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}show uses Python identifier show
    __show = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'show'), 'show', '__httpwww_isotc211_org2005gmd_MD_Band_PropertyType_httpwww_w3_org1999xlinkshow', _ImportedBinding_bindings_v1411_write__xlink.showType)
    __show._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 70, 1)
    __show._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 117, 2)
    
    show = property(__show.value, __show.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}actuate uses Python identifier actuate
    __actuate = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'actuate'), 'actuate', '__httpwww_isotc211_org2005gmd_MD_Band_PropertyType_httpwww_w3_org1999xlinkactuate', _ImportedBinding_bindings_v1411_write__xlink.actuateType)
    __actuate._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 82, 1)
    __actuate._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 118, 2)
    
    actuate = property(__actuate.value, __actuate.set, None, None)

    _ElementMap.update({
        __MD_Band.name() : __MD_Band
    })
    _AttributeMap.update({
        __uuidref.name() : __uuidref,
        __nilReason.name() : __nilReason,
        __type.name() : __type,
        __href.name() : __href,
        __role.name() : __role,
        __arcrole.name() : __arcrole,
        __title.name() : __title,
        __show.name() : __show,
        __actuate.name() : __actuate
    })
_module_typeBindings.MD_Band_PropertyType = MD_Band_PropertyType
_Namespace_gmd.addCategoryObject('typeBinding', 'MD_Band_PropertyType', MD_Band_PropertyType)


# Complex type {http://www.isotc211.org/2005/gmd}MD_CoverageContentTypeCode_PropertyType with content type ELEMENT_ONLY
class MD_CoverageContentTypeCode_PropertyType (pyxb.binding.basis.complexTypeDefinition):
    """Complex type {http://www.isotc211.org/2005/gmd}MD_CoverageContentTypeCode_PropertyType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_CoverageContentTypeCode_PropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/content.xsd', 173, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.isotc211.org/2005/gmd}MD_CoverageContentTypeCode uses Python identifier MD_CoverageContentTypeCode
    __MD_CoverageContentTypeCode = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_CoverageContentTypeCode'), 'MD_CoverageContentTypeCode', '__httpwww_isotc211_org2005gmd_MD_CoverageContentTypeCode_PropertyType_httpwww_isotc211_org2005gmdMD_CoverageContentTypeCode', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/content.xsd', 171, 1), )

    
    MD_CoverageContentTypeCode = property(__MD_CoverageContentTypeCode.value, __MD_CoverageContentTypeCode.set, None, None)

    
    # Attribute {http://www.isotc211.org/2005/gco}nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gco, 'nilReason'), 'nilReason', '__httpwww_isotc211_org2005gmd_MD_CoverageContentTypeCode_PropertyType_httpwww_isotc211_org2005gconilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 33, 1)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/content.xsd', 177, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    _ElementMap.update({
        __MD_CoverageContentTypeCode.name() : __MD_CoverageContentTypeCode
    })
    _AttributeMap.update({
        __nilReason.name() : __nilReason
    })
_module_typeBindings.MD_CoverageContentTypeCode_PropertyType = MD_CoverageContentTypeCode_PropertyType
_Namespace_gmd.addCategoryObject('typeBinding', 'MD_CoverageContentTypeCode_PropertyType', MD_CoverageContentTypeCode_PropertyType)


# Complex type {http://www.isotc211.org/2005/gmd}MD_ImagingConditionCode_PropertyType with content type ELEMENT_ONLY
class MD_ImagingConditionCode_PropertyType (pyxb.binding.basis.complexTypeDefinition):
    """Complex type {http://www.isotc211.org/2005/gmd}MD_ImagingConditionCode_PropertyType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_ImagingConditionCode_PropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/content.xsd', 183, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.isotc211.org/2005/gmd}MD_ImagingConditionCode uses Python identifier MD_ImagingConditionCode
    __MD_ImagingConditionCode = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_ImagingConditionCode'), 'MD_ImagingConditionCode', '__httpwww_isotc211_org2005gmd_MD_ImagingConditionCode_PropertyType_httpwww_isotc211_org2005gmdMD_ImagingConditionCode', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/content.xsd', 181, 1), )

    
    MD_ImagingConditionCode = property(__MD_ImagingConditionCode.value, __MD_ImagingConditionCode.set, None, None)

    
    # Attribute {http://www.isotc211.org/2005/gco}nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gco, 'nilReason'), 'nilReason', '__httpwww_isotc211_org2005gmd_MD_ImagingConditionCode_PropertyType_httpwww_isotc211_org2005gconilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 33, 1)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/content.xsd', 187, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    _ElementMap.update({
        __MD_ImagingConditionCode.name() : __MD_ImagingConditionCode
    })
    _AttributeMap.update({
        __nilReason.name() : __nilReason
    })
_module_typeBindings.MD_ImagingConditionCode_PropertyType = MD_ImagingConditionCode_PropertyType
_Namespace_gmd.addCategoryObject('typeBinding', 'MD_ImagingConditionCode_PropertyType', MD_ImagingConditionCode_PropertyType)


# Complex type {http://www.isotc211.org/2005/gmd}LI_ProcessStep_PropertyType with content type ELEMENT_ONLY
class LI_ProcessStep_PropertyType (pyxb.binding.basis.complexTypeDefinition):
    """Complex type {http://www.isotc211.org/2005/gmd}LI_ProcessStep_PropertyType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'LI_ProcessStep_PropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 31, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.isotc211.org/2005/gmd}LI_ProcessStep uses Python identifier LI_ProcessStep
    __LI_ProcessStep = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'LI_ProcessStep'), 'LI_ProcessStep', '__httpwww_isotc211_org2005gmd_LI_ProcessStep_PropertyType_httpwww_isotc211_org2005gmdLI_ProcessStep', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 29, 1), )

    
    LI_ProcessStep = property(__LI_ProcessStep.value, __LI_ProcessStep.set, None, None)

    
    # Attribute uuidref uses Python identifier uuidref
    __uuidref = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'uuidref'), 'uuidref', '__httpwww_isotc211_org2005gmd_LI_ProcessStep_PropertyType_uuidref', pyxb.binding.datatypes.string)
    __uuidref._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 30, 2)
    __uuidref._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 30, 2)
    
    uuidref = property(__uuidref.value, __uuidref.set, None, None)

    
    # Attribute {http://www.isotc211.org/2005/gco}nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gco, 'nilReason'), 'nilReason', '__httpwww_isotc211_org2005gmd_LI_ProcessStep_PropertyType_httpwww_isotc211_org2005gconilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 33, 1)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 36, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}type uses Python identifier type
    __type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'type'), 'type', '__httpwww_isotc211_org2005gmd_LI_ProcessStep_PropertyType_httpwww_w3_org1999xlinktype', _ImportedBinding_bindings_v1411_write__xlink.typeType, fixed=True, unicode_default='simple')
    __type._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 29, 1)
    __type._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 112, 2)
    
    type = property(__type.value, __type.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}href uses Python identifier href
    __href = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'href'), 'href', '__httpwww_isotc211_org2005gmd_LI_ProcessStep_PropertyType_httpwww_w3_org1999xlinkhref', _ImportedBinding_bindings_v1411_write__xlink.hrefType)
    __href._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 42, 1)
    __href._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 113, 2)
    
    href = property(__href.value, __href.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}role uses Python identifier role
    __role = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'role'), 'role', '__httpwww_isotc211_org2005gmd_LI_ProcessStep_PropertyType_httpwww_w3_org1999xlinkrole', _ImportedBinding_bindings_v1411_write__xlink.roleType)
    __role._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 48, 1)
    __role._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 114, 2)
    
    role = property(__role.value, __role.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}arcrole uses Python identifier arcrole
    __arcrole = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'arcrole'), 'arcrole', '__httpwww_isotc211_org2005gmd_LI_ProcessStep_PropertyType_httpwww_w3_org1999xlinkarcrole', _ImportedBinding_bindings_v1411_write__xlink.arcroleType)
    __arcrole._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 56, 1)
    __arcrole._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 115, 2)
    
    arcrole = property(__arcrole.value, __arcrole.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}title uses Python identifier title
    __title = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'title'), 'title', '__httpwww_isotc211_org2005gmd_LI_ProcessStep_PropertyType_httpwww_w3_org1999xlinktitle', _ImportedBinding_bindings_v1411_write__xlink.titleAttrType)
    __title._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 64, 1)
    __title._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 116, 2)
    
    title = property(__title.value, __title.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}show uses Python identifier show
    __show = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'show'), 'show', '__httpwww_isotc211_org2005gmd_LI_ProcessStep_PropertyType_httpwww_w3_org1999xlinkshow', _ImportedBinding_bindings_v1411_write__xlink.showType)
    __show._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 70, 1)
    __show._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 117, 2)
    
    show = property(__show.value, __show.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}actuate uses Python identifier actuate
    __actuate = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'actuate'), 'actuate', '__httpwww_isotc211_org2005gmd_LI_ProcessStep_PropertyType_httpwww_w3_org1999xlinkactuate', _ImportedBinding_bindings_v1411_write__xlink.actuateType)
    __actuate._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 82, 1)
    __actuate._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 118, 2)
    
    actuate = property(__actuate.value, __actuate.set, None, None)

    _ElementMap.update({
        __LI_ProcessStep.name() : __LI_ProcessStep
    })
    _AttributeMap.update({
        __uuidref.name() : __uuidref,
        __nilReason.name() : __nilReason,
        __type.name() : __type,
        __href.name() : __href,
        __role.name() : __role,
        __arcrole.name() : __arcrole,
        __title.name() : __title,
        __show.name() : __show,
        __actuate.name() : __actuate
    })
_module_typeBindings.LI_ProcessStep_PropertyType = LI_ProcessStep_PropertyType
_Namespace_gmd.addCategoryObject('typeBinding', 'LI_ProcessStep_PropertyType', LI_ProcessStep_PropertyType)


# Complex type {http://www.isotc211.org/2005/gmd}LI_Source_PropertyType with content type ELEMENT_ONLY
class LI_Source_PropertyType (pyxb.binding.basis.complexTypeDefinition):
    """Complex type {http://www.isotc211.org/2005/gmd}LI_Source_PropertyType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'LI_Source_PropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 56, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.isotc211.org/2005/gmd}LI_Source uses Python identifier LI_Source
    __LI_Source = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'LI_Source'), 'LI_Source', '__httpwww_isotc211_org2005gmd_LI_Source_PropertyType_httpwww_isotc211_org2005gmdLI_Source', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 54, 1), )

    
    LI_Source = property(__LI_Source.value, __LI_Source.set, None, None)

    
    # Attribute uuidref uses Python identifier uuidref
    __uuidref = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'uuidref'), 'uuidref', '__httpwww_isotc211_org2005gmd_LI_Source_PropertyType_uuidref', pyxb.binding.datatypes.string)
    __uuidref._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 30, 2)
    __uuidref._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 30, 2)
    
    uuidref = property(__uuidref.value, __uuidref.set, None, None)

    
    # Attribute {http://www.isotc211.org/2005/gco}nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gco, 'nilReason'), 'nilReason', '__httpwww_isotc211_org2005gmd_LI_Source_PropertyType_httpwww_isotc211_org2005gconilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 33, 1)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 61, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}type uses Python identifier type
    __type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'type'), 'type', '__httpwww_isotc211_org2005gmd_LI_Source_PropertyType_httpwww_w3_org1999xlinktype', _ImportedBinding_bindings_v1411_write__xlink.typeType, fixed=True, unicode_default='simple')
    __type._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 29, 1)
    __type._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 112, 2)
    
    type = property(__type.value, __type.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}href uses Python identifier href
    __href = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'href'), 'href', '__httpwww_isotc211_org2005gmd_LI_Source_PropertyType_httpwww_w3_org1999xlinkhref', _ImportedBinding_bindings_v1411_write__xlink.hrefType)
    __href._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 42, 1)
    __href._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 113, 2)
    
    href = property(__href.value, __href.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}role uses Python identifier role
    __role = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'role'), 'role', '__httpwww_isotc211_org2005gmd_LI_Source_PropertyType_httpwww_w3_org1999xlinkrole', _ImportedBinding_bindings_v1411_write__xlink.roleType)
    __role._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 48, 1)
    __role._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 114, 2)
    
    role = property(__role.value, __role.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}arcrole uses Python identifier arcrole
    __arcrole = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'arcrole'), 'arcrole', '__httpwww_isotc211_org2005gmd_LI_Source_PropertyType_httpwww_w3_org1999xlinkarcrole', _ImportedBinding_bindings_v1411_write__xlink.arcroleType)
    __arcrole._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 56, 1)
    __arcrole._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 115, 2)
    
    arcrole = property(__arcrole.value, __arcrole.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}title uses Python identifier title
    __title = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'title'), 'title', '__httpwww_isotc211_org2005gmd_LI_Source_PropertyType_httpwww_w3_org1999xlinktitle', _ImportedBinding_bindings_v1411_write__xlink.titleAttrType)
    __title._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 64, 1)
    __title._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 116, 2)
    
    title = property(__title.value, __title.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}show uses Python identifier show
    __show = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'show'), 'show', '__httpwww_isotc211_org2005gmd_LI_Source_PropertyType_httpwww_w3_org1999xlinkshow', _ImportedBinding_bindings_v1411_write__xlink.showType)
    __show._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 70, 1)
    __show._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 117, 2)
    
    show = property(__show.value, __show.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}actuate uses Python identifier actuate
    __actuate = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'actuate'), 'actuate', '__httpwww_isotc211_org2005gmd_LI_Source_PropertyType_httpwww_w3_org1999xlinkactuate', _ImportedBinding_bindings_v1411_write__xlink.actuateType)
    __actuate._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 82, 1)
    __actuate._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 118, 2)
    
    actuate = property(__actuate.value, __actuate.set, None, None)

    _ElementMap.update({
        __LI_Source.name() : __LI_Source
    })
    _AttributeMap.update({
        __uuidref.name() : __uuidref,
        __nilReason.name() : __nilReason,
        __type.name() : __type,
        __href.name() : __href,
        __role.name() : __role,
        __arcrole.name() : __arcrole,
        __title.name() : __title,
        __show.name() : __show,
        __actuate.name() : __actuate
    })
_module_typeBindings.LI_Source_PropertyType = LI_Source_PropertyType
_Namespace_gmd.addCategoryObject('typeBinding', 'LI_Source_PropertyType', LI_Source_PropertyType)


# Complex type {http://www.isotc211.org/2005/gmd}LI_Lineage_PropertyType with content type ELEMENT_ONLY
class LI_Lineage_PropertyType (pyxb.binding.basis.complexTypeDefinition):
    """Complex type {http://www.isotc211.org/2005/gmd}LI_Lineage_PropertyType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'LI_Lineage_PropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 78, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.isotc211.org/2005/gmd}LI_Lineage uses Python identifier LI_Lineage
    __LI_Lineage = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'LI_Lineage'), 'LI_Lineage', '__httpwww_isotc211_org2005gmd_LI_Lineage_PropertyType_httpwww_isotc211_org2005gmdLI_Lineage', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 76, 1), )

    
    LI_Lineage = property(__LI_Lineage.value, __LI_Lineage.set, None, None)

    
    # Attribute uuidref uses Python identifier uuidref
    __uuidref = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'uuidref'), 'uuidref', '__httpwww_isotc211_org2005gmd_LI_Lineage_PropertyType_uuidref', pyxb.binding.datatypes.string)
    __uuidref._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 30, 2)
    __uuidref._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 30, 2)
    
    uuidref = property(__uuidref.value, __uuidref.set, None, None)

    
    # Attribute {http://www.isotc211.org/2005/gco}nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gco, 'nilReason'), 'nilReason', '__httpwww_isotc211_org2005gmd_LI_Lineage_PropertyType_httpwww_isotc211_org2005gconilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 33, 1)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 83, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}type uses Python identifier type
    __type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'type'), 'type', '__httpwww_isotc211_org2005gmd_LI_Lineage_PropertyType_httpwww_w3_org1999xlinktype', _ImportedBinding_bindings_v1411_write__xlink.typeType, fixed=True, unicode_default='simple')
    __type._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 29, 1)
    __type._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 112, 2)
    
    type = property(__type.value, __type.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}href uses Python identifier href
    __href = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'href'), 'href', '__httpwww_isotc211_org2005gmd_LI_Lineage_PropertyType_httpwww_w3_org1999xlinkhref', _ImportedBinding_bindings_v1411_write__xlink.hrefType)
    __href._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 42, 1)
    __href._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 113, 2)
    
    href = property(__href.value, __href.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}role uses Python identifier role
    __role = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'role'), 'role', '__httpwww_isotc211_org2005gmd_LI_Lineage_PropertyType_httpwww_w3_org1999xlinkrole', _ImportedBinding_bindings_v1411_write__xlink.roleType)
    __role._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 48, 1)
    __role._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 114, 2)
    
    role = property(__role.value, __role.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}arcrole uses Python identifier arcrole
    __arcrole = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'arcrole'), 'arcrole', '__httpwww_isotc211_org2005gmd_LI_Lineage_PropertyType_httpwww_w3_org1999xlinkarcrole', _ImportedBinding_bindings_v1411_write__xlink.arcroleType)
    __arcrole._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 56, 1)
    __arcrole._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 115, 2)
    
    arcrole = property(__arcrole.value, __arcrole.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}title uses Python identifier title
    __title = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'title'), 'title', '__httpwww_isotc211_org2005gmd_LI_Lineage_PropertyType_httpwww_w3_org1999xlinktitle', _ImportedBinding_bindings_v1411_write__xlink.titleAttrType)
    __title._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 64, 1)
    __title._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 116, 2)
    
    title = property(__title.value, __title.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}show uses Python identifier show
    __show = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'show'), 'show', '__httpwww_isotc211_org2005gmd_LI_Lineage_PropertyType_httpwww_w3_org1999xlinkshow', _ImportedBinding_bindings_v1411_write__xlink.showType)
    __show._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 70, 1)
    __show._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 117, 2)
    
    show = property(__show.value, __show.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}actuate uses Python identifier actuate
    __actuate = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'actuate'), 'actuate', '__httpwww_isotc211_org2005gmd_LI_Lineage_PropertyType_httpwww_w3_org1999xlinkactuate', _ImportedBinding_bindings_v1411_write__xlink.actuateType)
    __actuate._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 82, 1)
    __actuate._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 118, 2)
    
    actuate = property(__actuate.value, __actuate.set, None, None)

    _ElementMap.update({
        __LI_Lineage.name() : __LI_Lineage
    })
    _AttributeMap.update({
        __uuidref.name() : __uuidref,
        __nilReason.name() : __nilReason,
        __type.name() : __type,
        __href.name() : __href,
        __role.name() : __role,
        __arcrole.name() : __arcrole,
        __title.name() : __title,
        __show.name() : __show,
        __actuate.name() : __actuate
    })
_module_typeBindings.LI_Lineage_PropertyType = LI_Lineage_PropertyType
_Namespace_gmd.addCategoryObject('typeBinding', 'LI_Lineage_PropertyType', LI_Lineage_PropertyType)


# Complex type {http://www.isotc211.org/2005/gmd}DQ_ConformanceResult_Type with content type ELEMENT_ONLY
class DQ_ConformanceResult_Type (AbstractDQ_Result_Type):
    """quantitative_result from Quality Procedures -  - renamed to remove implied use limitiation."""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'DQ_ConformanceResult_Type')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 86, 1)
    _ElementMap = AbstractDQ_Result_Type._ElementMap.copy()
    _AttributeMap = AbstractDQ_Result_Type._AttributeMap.copy()
    # Base type is AbstractDQ_Result_Type
    
    # Element {http://www.isotc211.org/2005/gmd}specification uses Python identifier specification
    __specification = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'specification'), 'specification', '__httpwww_isotc211_org2005gmd_DQ_ConformanceResult_Type_httpwww_isotc211_org2005gmdspecification', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 93, 5), )

    
    specification = property(__specification.value, __specification.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}explanation uses Python identifier explanation
    __explanation = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'explanation'), 'explanation', '__httpwww_isotc211_org2005gmd_DQ_ConformanceResult_Type_httpwww_isotc211_org2005gmdexplanation', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 94, 5), )

    
    explanation = property(__explanation.value, __explanation.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}pass uses Python identifier pass_
    __pass = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'pass'), 'pass_', '__httpwww_isotc211_org2005gmd_DQ_ConformanceResult_Type_httpwww_isotc211_org2005gmdpass', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 95, 5), )

    
    pass_ = property(__pass.value, __pass.set, None, None)

    
    # Attribute id inherited from {http://www.isotc211.org/2005/gco}AbstractObject_Type
    
    # Attribute uuid inherited from {http://www.isotc211.org/2005/gco}AbstractObject_Type
    _ElementMap.update({
        __specification.name() : __specification,
        __explanation.name() : __explanation,
        __pass.name() : __pass
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.DQ_ConformanceResult_Type = DQ_ConformanceResult_Type
_Namespace_gmd.addCategoryObject('typeBinding', 'DQ_ConformanceResult_Type', DQ_ConformanceResult_Type)


# Complex type {http://www.isotc211.org/2005/gmd}DQ_ConformanceResult_PropertyType with content type ELEMENT_ONLY
class DQ_ConformanceResult_PropertyType (pyxb.binding.basis.complexTypeDefinition):
    """Complex type {http://www.isotc211.org/2005/gmd}DQ_ConformanceResult_PropertyType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'DQ_ConformanceResult_PropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 103, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.isotc211.org/2005/gmd}DQ_ConformanceResult uses Python identifier DQ_ConformanceResult
    __DQ_ConformanceResult = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'DQ_ConformanceResult'), 'DQ_ConformanceResult', '__httpwww_isotc211_org2005gmd_DQ_ConformanceResult_PropertyType_httpwww_isotc211_org2005gmdDQ_ConformanceResult', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 101, 1), )

    
    DQ_ConformanceResult = property(__DQ_ConformanceResult.value, __DQ_ConformanceResult.set, None, None)

    
    # Attribute uuidref uses Python identifier uuidref
    __uuidref = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'uuidref'), 'uuidref', '__httpwww_isotc211_org2005gmd_DQ_ConformanceResult_PropertyType_uuidref', pyxb.binding.datatypes.string)
    __uuidref._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 30, 2)
    __uuidref._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 30, 2)
    
    uuidref = property(__uuidref.value, __uuidref.set, None, None)

    
    # Attribute {http://www.isotc211.org/2005/gco}nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gco, 'nilReason'), 'nilReason', '__httpwww_isotc211_org2005gmd_DQ_ConformanceResult_PropertyType_httpwww_isotc211_org2005gconilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 33, 1)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 108, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}type uses Python identifier type
    __type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'type'), 'type', '__httpwww_isotc211_org2005gmd_DQ_ConformanceResult_PropertyType_httpwww_w3_org1999xlinktype', _ImportedBinding_bindings_v1411_write__xlink.typeType, fixed=True, unicode_default='simple')
    __type._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 29, 1)
    __type._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 112, 2)
    
    type = property(__type.value, __type.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}href uses Python identifier href
    __href = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'href'), 'href', '__httpwww_isotc211_org2005gmd_DQ_ConformanceResult_PropertyType_httpwww_w3_org1999xlinkhref', _ImportedBinding_bindings_v1411_write__xlink.hrefType)
    __href._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 42, 1)
    __href._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 113, 2)
    
    href = property(__href.value, __href.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}role uses Python identifier role
    __role = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'role'), 'role', '__httpwww_isotc211_org2005gmd_DQ_ConformanceResult_PropertyType_httpwww_w3_org1999xlinkrole', _ImportedBinding_bindings_v1411_write__xlink.roleType)
    __role._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 48, 1)
    __role._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 114, 2)
    
    role = property(__role.value, __role.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}arcrole uses Python identifier arcrole
    __arcrole = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'arcrole'), 'arcrole', '__httpwww_isotc211_org2005gmd_DQ_ConformanceResult_PropertyType_httpwww_w3_org1999xlinkarcrole', _ImportedBinding_bindings_v1411_write__xlink.arcroleType)
    __arcrole._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 56, 1)
    __arcrole._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 115, 2)
    
    arcrole = property(__arcrole.value, __arcrole.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}title uses Python identifier title
    __title = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'title'), 'title', '__httpwww_isotc211_org2005gmd_DQ_ConformanceResult_PropertyType_httpwww_w3_org1999xlinktitle', _ImportedBinding_bindings_v1411_write__xlink.titleAttrType)
    __title._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 64, 1)
    __title._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 116, 2)
    
    title = property(__title.value, __title.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}show uses Python identifier show
    __show = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'show'), 'show', '__httpwww_isotc211_org2005gmd_DQ_ConformanceResult_PropertyType_httpwww_w3_org1999xlinkshow', _ImportedBinding_bindings_v1411_write__xlink.showType)
    __show._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 70, 1)
    __show._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 117, 2)
    
    show = property(__show.value, __show.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}actuate uses Python identifier actuate
    __actuate = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'actuate'), 'actuate', '__httpwww_isotc211_org2005gmd_DQ_ConformanceResult_PropertyType_httpwww_w3_org1999xlinkactuate', _ImportedBinding_bindings_v1411_write__xlink.actuateType)
    __actuate._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 82, 1)
    __actuate._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 118, 2)
    
    actuate = property(__actuate.value, __actuate.set, None, None)

    _ElementMap.update({
        __DQ_ConformanceResult.name() : __DQ_ConformanceResult
    })
    _AttributeMap.update({
        __uuidref.name() : __uuidref,
        __nilReason.name() : __nilReason,
        __type.name() : __type,
        __href.name() : __href,
        __role.name() : __role,
        __arcrole.name() : __arcrole,
        __title.name() : __title,
        __show.name() : __show,
        __actuate.name() : __actuate
    })
_module_typeBindings.DQ_ConformanceResult_PropertyType = DQ_ConformanceResult_PropertyType
_Namespace_gmd.addCategoryObject('typeBinding', 'DQ_ConformanceResult_PropertyType', DQ_ConformanceResult_PropertyType)


# Complex type {http://www.isotc211.org/2005/gmd}DQ_QuantitativeResult_Type with content type ELEMENT_ONLY
class DQ_QuantitativeResult_Type (AbstractDQ_Result_Type):
    """Quantitative_conformance_measure from Quality Procedures.  -  - Renamed to remove implied use limitation -  - OCL - -- result is type specified by valueDomain - result.tupleType = valueDomain"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'DQ_QuantitativeResult_Type')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 111, 1)
    _ElementMap = AbstractDQ_Result_Type._ElementMap.copy()
    _AttributeMap = AbstractDQ_Result_Type._AttributeMap.copy()
    # Base type is AbstractDQ_Result_Type
    
    # Element {http://www.isotc211.org/2005/gmd}valueType uses Python identifier valueType
    __valueType = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'valueType'), 'valueType', '__httpwww_isotc211_org2005gmd_DQ_QuantitativeResult_Type_httpwww_isotc211_org2005gmdvalueType', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 118, 5), )

    
    valueType = property(__valueType.value, __valueType.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}valueUnit uses Python identifier valueUnit
    __valueUnit = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'valueUnit'), 'valueUnit', '__httpwww_isotc211_org2005gmd_DQ_QuantitativeResult_Type_httpwww_isotc211_org2005gmdvalueUnit', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 119, 5), )

    
    valueUnit = property(__valueUnit.value, __valueUnit.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}errorStatistic uses Python identifier errorStatistic
    __errorStatistic = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'errorStatistic'), 'errorStatistic', '__httpwww_isotc211_org2005gmd_DQ_QuantitativeResult_Type_httpwww_isotc211_org2005gmderrorStatistic', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 120, 5), )

    
    errorStatistic = property(__errorStatistic.value, __errorStatistic.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}value uses Python identifier value_
    __value = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'value'), 'value_', '__httpwww_isotc211_org2005gmd_DQ_QuantitativeResult_Type_httpwww_isotc211_org2005gmdvalue', True, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 121, 5), )

    
    value_ = property(__value.value, __value.set, None, None)

    
    # Attribute id inherited from {http://www.isotc211.org/2005/gco}AbstractObject_Type
    
    # Attribute uuid inherited from {http://www.isotc211.org/2005/gco}AbstractObject_Type
    _ElementMap.update({
        __valueType.name() : __valueType,
        __valueUnit.name() : __valueUnit,
        __errorStatistic.name() : __errorStatistic,
        __value.name() : __value
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.DQ_QuantitativeResult_Type = DQ_QuantitativeResult_Type
_Namespace_gmd.addCategoryObject('typeBinding', 'DQ_QuantitativeResult_Type', DQ_QuantitativeResult_Type)


# Complex type {http://www.isotc211.org/2005/gmd}DQ_QuantitativeResult_PropertyType with content type ELEMENT_ONLY
class DQ_QuantitativeResult_PropertyType (pyxb.binding.basis.complexTypeDefinition):
    """Complex type {http://www.isotc211.org/2005/gmd}DQ_QuantitativeResult_PropertyType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'DQ_QuantitativeResult_PropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 129, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.isotc211.org/2005/gmd}DQ_QuantitativeResult uses Python identifier DQ_QuantitativeResult
    __DQ_QuantitativeResult = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'DQ_QuantitativeResult'), 'DQ_QuantitativeResult', '__httpwww_isotc211_org2005gmd_DQ_QuantitativeResult_PropertyType_httpwww_isotc211_org2005gmdDQ_QuantitativeResult', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 127, 1), )

    
    DQ_QuantitativeResult = property(__DQ_QuantitativeResult.value, __DQ_QuantitativeResult.set, None, None)

    
    # Attribute uuidref uses Python identifier uuidref
    __uuidref = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'uuidref'), 'uuidref', '__httpwww_isotc211_org2005gmd_DQ_QuantitativeResult_PropertyType_uuidref', pyxb.binding.datatypes.string)
    __uuidref._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 30, 2)
    __uuidref._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 30, 2)
    
    uuidref = property(__uuidref.value, __uuidref.set, None, None)

    
    # Attribute {http://www.isotc211.org/2005/gco}nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gco, 'nilReason'), 'nilReason', '__httpwww_isotc211_org2005gmd_DQ_QuantitativeResult_PropertyType_httpwww_isotc211_org2005gconilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 33, 1)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 134, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}type uses Python identifier type
    __type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'type'), 'type', '__httpwww_isotc211_org2005gmd_DQ_QuantitativeResult_PropertyType_httpwww_w3_org1999xlinktype', _ImportedBinding_bindings_v1411_write__xlink.typeType, fixed=True, unicode_default='simple')
    __type._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 29, 1)
    __type._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 112, 2)
    
    type = property(__type.value, __type.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}href uses Python identifier href
    __href = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'href'), 'href', '__httpwww_isotc211_org2005gmd_DQ_QuantitativeResult_PropertyType_httpwww_w3_org1999xlinkhref', _ImportedBinding_bindings_v1411_write__xlink.hrefType)
    __href._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 42, 1)
    __href._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 113, 2)
    
    href = property(__href.value, __href.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}role uses Python identifier role
    __role = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'role'), 'role', '__httpwww_isotc211_org2005gmd_DQ_QuantitativeResult_PropertyType_httpwww_w3_org1999xlinkrole', _ImportedBinding_bindings_v1411_write__xlink.roleType)
    __role._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 48, 1)
    __role._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 114, 2)
    
    role = property(__role.value, __role.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}arcrole uses Python identifier arcrole
    __arcrole = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'arcrole'), 'arcrole', '__httpwww_isotc211_org2005gmd_DQ_QuantitativeResult_PropertyType_httpwww_w3_org1999xlinkarcrole', _ImportedBinding_bindings_v1411_write__xlink.arcroleType)
    __arcrole._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 56, 1)
    __arcrole._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 115, 2)
    
    arcrole = property(__arcrole.value, __arcrole.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}title uses Python identifier title
    __title = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'title'), 'title', '__httpwww_isotc211_org2005gmd_DQ_QuantitativeResult_PropertyType_httpwww_w3_org1999xlinktitle', _ImportedBinding_bindings_v1411_write__xlink.titleAttrType)
    __title._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 64, 1)
    __title._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 116, 2)
    
    title = property(__title.value, __title.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}show uses Python identifier show
    __show = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'show'), 'show', '__httpwww_isotc211_org2005gmd_DQ_QuantitativeResult_PropertyType_httpwww_w3_org1999xlinkshow', _ImportedBinding_bindings_v1411_write__xlink.showType)
    __show._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 70, 1)
    __show._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 117, 2)
    
    show = property(__show.value, __show.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}actuate uses Python identifier actuate
    __actuate = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'actuate'), 'actuate', '__httpwww_isotc211_org2005gmd_DQ_QuantitativeResult_PropertyType_httpwww_w3_org1999xlinkactuate', _ImportedBinding_bindings_v1411_write__xlink.actuateType)
    __actuate._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 82, 1)
    __actuate._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 118, 2)
    
    actuate = property(__actuate.value, __actuate.set, None, None)

    _ElementMap.update({
        __DQ_QuantitativeResult.name() : __DQ_QuantitativeResult
    })
    _AttributeMap.update({
        __uuidref.name() : __uuidref,
        __nilReason.name() : __nilReason,
        __type.name() : __type,
        __href.name() : __href,
        __role.name() : __role,
        __arcrole.name() : __arcrole,
        __title.name() : __title,
        __show.name() : __show,
        __actuate.name() : __actuate
    })
_module_typeBindings.DQ_QuantitativeResult_PropertyType = DQ_QuantitativeResult_PropertyType
_Namespace_gmd.addCategoryObject('typeBinding', 'DQ_QuantitativeResult_PropertyType', DQ_QuantitativeResult_PropertyType)


# Complex type {http://www.isotc211.org/2005/gmd}DQ_Result_PropertyType with content type ELEMENT_ONLY
class DQ_Result_PropertyType (pyxb.binding.basis.complexTypeDefinition):
    """Complex type {http://www.isotc211.org/2005/gmd}DQ_Result_PropertyType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'DQ_Result_PropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 147, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.isotc211.org/2005/gmd}AbstractDQ_Result uses Python identifier AbstractDQ_Result
    __AbstractDQ_Result = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'AbstractDQ_Result'), 'AbstractDQ_Result', '__httpwww_isotc211_org2005gmd_DQ_Result_PropertyType_httpwww_isotc211_org2005gmdAbstractDQ_Result', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 145, 1), )

    
    AbstractDQ_Result = property(__AbstractDQ_Result.value, __AbstractDQ_Result.set, None, None)

    
    # Attribute uuidref uses Python identifier uuidref
    __uuidref = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'uuidref'), 'uuidref', '__httpwww_isotc211_org2005gmd_DQ_Result_PropertyType_uuidref', pyxb.binding.datatypes.string)
    __uuidref._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 30, 2)
    __uuidref._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 30, 2)
    
    uuidref = property(__uuidref.value, __uuidref.set, None, None)

    
    # Attribute {http://www.isotc211.org/2005/gco}nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gco, 'nilReason'), 'nilReason', '__httpwww_isotc211_org2005gmd_DQ_Result_PropertyType_httpwww_isotc211_org2005gconilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 33, 1)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 152, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}type uses Python identifier type
    __type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'type'), 'type', '__httpwww_isotc211_org2005gmd_DQ_Result_PropertyType_httpwww_w3_org1999xlinktype', _ImportedBinding_bindings_v1411_write__xlink.typeType, fixed=True, unicode_default='simple')
    __type._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 29, 1)
    __type._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 112, 2)
    
    type = property(__type.value, __type.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}href uses Python identifier href
    __href = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'href'), 'href', '__httpwww_isotc211_org2005gmd_DQ_Result_PropertyType_httpwww_w3_org1999xlinkhref', _ImportedBinding_bindings_v1411_write__xlink.hrefType)
    __href._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 42, 1)
    __href._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 113, 2)
    
    href = property(__href.value, __href.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}role uses Python identifier role
    __role = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'role'), 'role', '__httpwww_isotc211_org2005gmd_DQ_Result_PropertyType_httpwww_w3_org1999xlinkrole', _ImportedBinding_bindings_v1411_write__xlink.roleType)
    __role._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 48, 1)
    __role._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 114, 2)
    
    role = property(__role.value, __role.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}arcrole uses Python identifier arcrole
    __arcrole = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'arcrole'), 'arcrole', '__httpwww_isotc211_org2005gmd_DQ_Result_PropertyType_httpwww_w3_org1999xlinkarcrole', _ImportedBinding_bindings_v1411_write__xlink.arcroleType)
    __arcrole._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 56, 1)
    __arcrole._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 115, 2)
    
    arcrole = property(__arcrole.value, __arcrole.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}title uses Python identifier title
    __title = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'title'), 'title', '__httpwww_isotc211_org2005gmd_DQ_Result_PropertyType_httpwww_w3_org1999xlinktitle', _ImportedBinding_bindings_v1411_write__xlink.titleAttrType)
    __title._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 64, 1)
    __title._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 116, 2)
    
    title = property(__title.value, __title.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}show uses Python identifier show
    __show = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'show'), 'show', '__httpwww_isotc211_org2005gmd_DQ_Result_PropertyType_httpwww_w3_org1999xlinkshow', _ImportedBinding_bindings_v1411_write__xlink.showType)
    __show._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 70, 1)
    __show._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 117, 2)
    
    show = property(__show.value, __show.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}actuate uses Python identifier actuate
    __actuate = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'actuate'), 'actuate', '__httpwww_isotc211_org2005gmd_DQ_Result_PropertyType_httpwww_w3_org1999xlinkactuate', _ImportedBinding_bindings_v1411_write__xlink.actuateType)
    __actuate._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 82, 1)
    __actuate._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 118, 2)
    
    actuate = property(__actuate.value, __actuate.set, None, None)

    _ElementMap.update({
        __AbstractDQ_Result.name() : __AbstractDQ_Result
    })
    _AttributeMap.update({
        __uuidref.name() : __uuidref,
        __nilReason.name() : __nilReason,
        __type.name() : __type,
        __href.name() : __href,
        __role.name() : __role,
        __arcrole.name() : __arcrole,
        __title.name() : __title,
        __show.name() : __show,
        __actuate.name() : __actuate
    })
_module_typeBindings.DQ_Result_PropertyType = DQ_Result_PropertyType
_Namespace_gmd.addCategoryObject('typeBinding', 'DQ_Result_PropertyType', DQ_Result_PropertyType)


# Complex type {http://www.isotc211.org/2005/gmd}DQ_TemporalValidity_PropertyType with content type ELEMENT_ONLY
class DQ_TemporalValidity_PropertyType (pyxb.binding.basis.complexTypeDefinition):
    """Complex type {http://www.isotc211.org/2005/gmd}DQ_TemporalValidity_PropertyType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'DQ_TemporalValidity_PropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 163, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.isotc211.org/2005/gmd}DQ_TemporalValidity uses Python identifier DQ_TemporalValidity
    __DQ_TemporalValidity = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'DQ_TemporalValidity'), 'DQ_TemporalValidity', '__httpwww_isotc211_org2005gmd_DQ_TemporalValidity_PropertyType_httpwww_isotc211_org2005gmdDQ_TemporalValidity', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 161, 1), )

    
    DQ_TemporalValidity = property(__DQ_TemporalValidity.value, __DQ_TemporalValidity.set, None, None)

    
    # Attribute uuidref uses Python identifier uuidref
    __uuidref = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'uuidref'), 'uuidref', '__httpwww_isotc211_org2005gmd_DQ_TemporalValidity_PropertyType_uuidref', pyxb.binding.datatypes.string)
    __uuidref._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 30, 2)
    __uuidref._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 30, 2)
    
    uuidref = property(__uuidref.value, __uuidref.set, None, None)

    
    # Attribute {http://www.isotc211.org/2005/gco}nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gco, 'nilReason'), 'nilReason', '__httpwww_isotc211_org2005gmd_DQ_TemporalValidity_PropertyType_httpwww_isotc211_org2005gconilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 33, 1)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 168, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}type uses Python identifier type
    __type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'type'), 'type', '__httpwww_isotc211_org2005gmd_DQ_TemporalValidity_PropertyType_httpwww_w3_org1999xlinktype', _ImportedBinding_bindings_v1411_write__xlink.typeType, fixed=True, unicode_default='simple')
    __type._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 29, 1)
    __type._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 112, 2)
    
    type = property(__type.value, __type.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}href uses Python identifier href
    __href = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'href'), 'href', '__httpwww_isotc211_org2005gmd_DQ_TemporalValidity_PropertyType_httpwww_w3_org1999xlinkhref', _ImportedBinding_bindings_v1411_write__xlink.hrefType)
    __href._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 42, 1)
    __href._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 113, 2)
    
    href = property(__href.value, __href.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}role uses Python identifier role
    __role = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'role'), 'role', '__httpwww_isotc211_org2005gmd_DQ_TemporalValidity_PropertyType_httpwww_w3_org1999xlinkrole', _ImportedBinding_bindings_v1411_write__xlink.roleType)
    __role._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 48, 1)
    __role._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 114, 2)
    
    role = property(__role.value, __role.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}arcrole uses Python identifier arcrole
    __arcrole = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'arcrole'), 'arcrole', '__httpwww_isotc211_org2005gmd_DQ_TemporalValidity_PropertyType_httpwww_w3_org1999xlinkarcrole', _ImportedBinding_bindings_v1411_write__xlink.arcroleType)
    __arcrole._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 56, 1)
    __arcrole._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 115, 2)
    
    arcrole = property(__arcrole.value, __arcrole.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}title uses Python identifier title
    __title = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'title'), 'title', '__httpwww_isotc211_org2005gmd_DQ_TemporalValidity_PropertyType_httpwww_w3_org1999xlinktitle', _ImportedBinding_bindings_v1411_write__xlink.titleAttrType)
    __title._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 64, 1)
    __title._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 116, 2)
    
    title = property(__title.value, __title.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}show uses Python identifier show
    __show = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'show'), 'show', '__httpwww_isotc211_org2005gmd_DQ_TemporalValidity_PropertyType_httpwww_w3_org1999xlinkshow', _ImportedBinding_bindings_v1411_write__xlink.showType)
    __show._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 70, 1)
    __show._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 117, 2)
    
    show = property(__show.value, __show.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}actuate uses Python identifier actuate
    __actuate = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'actuate'), 'actuate', '__httpwww_isotc211_org2005gmd_DQ_TemporalValidity_PropertyType_httpwww_w3_org1999xlinkactuate', _ImportedBinding_bindings_v1411_write__xlink.actuateType)
    __actuate._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 82, 1)
    __actuate._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 118, 2)
    
    actuate = property(__actuate.value, __actuate.set, None, None)

    _ElementMap.update({
        __DQ_TemporalValidity.name() : __DQ_TemporalValidity
    })
    _AttributeMap.update({
        __uuidref.name() : __uuidref,
        __nilReason.name() : __nilReason,
        __type.name() : __type,
        __href.name() : __href,
        __role.name() : __role,
        __arcrole.name() : __arcrole,
        __title.name() : __title,
        __show.name() : __show,
        __actuate.name() : __actuate
    })
_module_typeBindings.DQ_TemporalValidity_PropertyType = DQ_TemporalValidity_PropertyType
_Namespace_gmd.addCategoryObject('typeBinding', 'DQ_TemporalValidity_PropertyType', DQ_TemporalValidity_PropertyType)


# Complex type {http://www.isotc211.org/2005/gmd}DQ_TemporalConsistency_PropertyType with content type ELEMENT_ONLY
class DQ_TemporalConsistency_PropertyType (pyxb.binding.basis.complexTypeDefinition):
    """Complex type {http://www.isotc211.org/2005/gmd}DQ_TemporalConsistency_PropertyType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'DQ_TemporalConsistency_PropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 179, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.isotc211.org/2005/gmd}DQ_TemporalConsistency uses Python identifier DQ_TemporalConsistency
    __DQ_TemporalConsistency = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'DQ_TemporalConsistency'), 'DQ_TemporalConsistency', '__httpwww_isotc211_org2005gmd_DQ_TemporalConsistency_PropertyType_httpwww_isotc211_org2005gmdDQ_TemporalConsistency', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 177, 1), )

    
    DQ_TemporalConsistency = property(__DQ_TemporalConsistency.value, __DQ_TemporalConsistency.set, None, None)

    
    # Attribute uuidref uses Python identifier uuidref
    __uuidref = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'uuidref'), 'uuidref', '__httpwww_isotc211_org2005gmd_DQ_TemporalConsistency_PropertyType_uuidref', pyxb.binding.datatypes.string)
    __uuidref._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 30, 2)
    __uuidref._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 30, 2)
    
    uuidref = property(__uuidref.value, __uuidref.set, None, None)

    
    # Attribute {http://www.isotc211.org/2005/gco}nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gco, 'nilReason'), 'nilReason', '__httpwww_isotc211_org2005gmd_DQ_TemporalConsistency_PropertyType_httpwww_isotc211_org2005gconilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 33, 1)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 184, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}type uses Python identifier type
    __type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'type'), 'type', '__httpwww_isotc211_org2005gmd_DQ_TemporalConsistency_PropertyType_httpwww_w3_org1999xlinktype', _ImportedBinding_bindings_v1411_write__xlink.typeType, fixed=True, unicode_default='simple')
    __type._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 29, 1)
    __type._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 112, 2)
    
    type = property(__type.value, __type.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}href uses Python identifier href
    __href = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'href'), 'href', '__httpwww_isotc211_org2005gmd_DQ_TemporalConsistency_PropertyType_httpwww_w3_org1999xlinkhref', _ImportedBinding_bindings_v1411_write__xlink.hrefType)
    __href._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 42, 1)
    __href._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 113, 2)
    
    href = property(__href.value, __href.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}role uses Python identifier role
    __role = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'role'), 'role', '__httpwww_isotc211_org2005gmd_DQ_TemporalConsistency_PropertyType_httpwww_w3_org1999xlinkrole', _ImportedBinding_bindings_v1411_write__xlink.roleType)
    __role._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 48, 1)
    __role._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 114, 2)
    
    role = property(__role.value, __role.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}arcrole uses Python identifier arcrole
    __arcrole = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'arcrole'), 'arcrole', '__httpwww_isotc211_org2005gmd_DQ_TemporalConsistency_PropertyType_httpwww_w3_org1999xlinkarcrole', _ImportedBinding_bindings_v1411_write__xlink.arcroleType)
    __arcrole._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 56, 1)
    __arcrole._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 115, 2)
    
    arcrole = property(__arcrole.value, __arcrole.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}title uses Python identifier title
    __title = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'title'), 'title', '__httpwww_isotc211_org2005gmd_DQ_TemporalConsistency_PropertyType_httpwww_w3_org1999xlinktitle', _ImportedBinding_bindings_v1411_write__xlink.titleAttrType)
    __title._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 64, 1)
    __title._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 116, 2)
    
    title = property(__title.value, __title.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}show uses Python identifier show
    __show = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'show'), 'show', '__httpwww_isotc211_org2005gmd_DQ_TemporalConsistency_PropertyType_httpwww_w3_org1999xlinkshow', _ImportedBinding_bindings_v1411_write__xlink.showType)
    __show._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 70, 1)
    __show._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 117, 2)
    
    show = property(__show.value, __show.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}actuate uses Python identifier actuate
    __actuate = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'actuate'), 'actuate', '__httpwww_isotc211_org2005gmd_DQ_TemporalConsistency_PropertyType_httpwww_w3_org1999xlinkactuate', _ImportedBinding_bindings_v1411_write__xlink.actuateType)
    __actuate._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 82, 1)
    __actuate._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 118, 2)
    
    actuate = property(__actuate.value, __actuate.set, None, None)

    _ElementMap.update({
        __DQ_TemporalConsistency.name() : __DQ_TemporalConsistency
    })
    _AttributeMap.update({
        __uuidref.name() : __uuidref,
        __nilReason.name() : __nilReason,
        __type.name() : __type,
        __href.name() : __href,
        __role.name() : __role,
        __arcrole.name() : __arcrole,
        __title.name() : __title,
        __show.name() : __show,
        __actuate.name() : __actuate
    })
_module_typeBindings.DQ_TemporalConsistency_PropertyType = DQ_TemporalConsistency_PropertyType
_Namespace_gmd.addCategoryObject('typeBinding', 'DQ_TemporalConsistency_PropertyType', DQ_TemporalConsistency_PropertyType)


# Complex type {http://www.isotc211.org/2005/gmd}DQ_AccuracyOfATimeMeasurement_PropertyType with content type ELEMENT_ONLY
class DQ_AccuracyOfATimeMeasurement_PropertyType (pyxb.binding.basis.complexTypeDefinition):
    """Complex type {http://www.isotc211.org/2005/gmd}DQ_AccuracyOfATimeMeasurement_PropertyType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'DQ_AccuracyOfATimeMeasurement_PropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 195, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.isotc211.org/2005/gmd}DQ_AccuracyOfATimeMeasurement uses Python identifier DQ_AccuracyOfATimeMeasurement
    __DQ_AccuracyOfATimeMeasurement = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'DQ_AccuracyOfATimeMeasurement'), 'DQ_AccuracyOfATimeMeasurement', '__httpwww_isotc211_org2005gmd_DQ_AccuracyOfATimeMeasurement_PropertyType_httpwww_isotc211_org2005gmdDQ_AccuracyOfATimeMeasurement', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 193, 1), )

    
    DQ_AccuracyOfATimeMeasurement = property(__DQ_AccuracyOfATimeMeasurement.value, __DQ_AccuracyOfATimeMeasurement.set, None, None)

    
    # Attribute uuidref uses Python identifier uuidref
    __uuidref = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'uuidref'), 'uuidref', '__httpwww_isotc211_org2005gmd_DQ_AccuracyOfATimeMeasurement_PropertyType_uuidref', pyxb.binding.datatypes.string)
    __uuidref._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 30, 2)
    __uuidref._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 30, 2)
    
    uuidref = property(__uuidref.value, __uuidref.set, None, None)

    
    # Attribute {http://www.isotc211.org/2005/gco}nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gco, 'nilReason'), 'nilReason', '__httpwww_isotc211_org2005gmd_DQ_AccuracyOfATimeMeasurement_PropertyType_httpwww_isotc211_org2005gconilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 33, 1)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 200, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}type uses Python identifier type
    __type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'type'), 'type', '__httpwww_isotc211_org2005gmd_DQ_AccuracyOfATimeMeasurement_PropertyType_httpwww_w3_org1999xlinktype', _ImportedBinding_bindings_v1411_write__xlink.typeType, fixed=True, unicode_default='simple')
    __type._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 29, 1)
    __type._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 112, 2)
    
    type = property(__type.value, __type.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}href uses Python identifier href
    __href = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'href'), 'href', '__httpwww_isotc211_org2005gmd_DQ_AccuracyOfATimeMeasurement_PropertyType_httpwww_w3_org1999xlinkhref', _ImportedBinding_bindings_v1411_write__xlink.hrefType)
    __href._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 42, 1)
    __href._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 113, 2)
    
    href = property(__href.value, __href.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}role uses Python identifier role
    __role = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'role'), 'role', '__httpwww_isotc211_org2005gmd_DQ_AccuracyOfATimeMeasurement_PropertyType_httpwww_w3_org1999xlinkrole', _ImportedBinding_bindings_v1411_write__xlink.roleType)
    __role._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 48, 1)
    __role._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 114, 2)
    
    role = property(__role.value, __role.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}arcrole uses Python identifier arcrole
    __arcrole = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'arcrole'), 'arcrole', '__httpwww_isotc211_org2005gmd_DQ_AccuracyOfATimeMeasurement_PropertyType_httpwww_w3_org1999xlinkarcrole', _ImportedBinding_bindings_v1411_write__xlink.arcroleType)
    __arcrole._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 56, 1)
    __arcrole._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 115, 2)
    
    arcrole = property(__arcrole.value, __arcrole.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}title uses Python identifier title
    __title = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'title'), 'title', '__httpwww_isotc211_org2005gmd_DQ_AccuracyOfATimeMeasurement_PropertyType_httpwww_w3_org1999xlinktitle', _ImportedBinding_bindings_v1411_write__xlink.titleAttrType)
    __title._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 64, 1)
    __title._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 116, 2)
    
    title = property(__title.value, __title.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}show uses Python identifier show
    __show = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'show'), 'show', '__httpwww_isotc211_org2005gmd_DQ_AccuracyOfATimeMeasurement_PropertyType_httpwww_w3_org1999xlinkshow', _ImportedBinding_bindings_v1411_write__xlink.showType)
    __show._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 70, 1)
    __show._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 117, 2)
    
    show = property(__show.value, __show.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}actuate uses Python identifier actuate
    __actuate = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'actuate'), 'actuate', '__httpwww_isotc211_org2005gmd_DQ_AccuracyOfATimeMeasurement_PropertyType_httpwww_w3_org1999xlinkactuate', _ImportedBinding_bindings_v1411_write__xlink.actuateType)
    __actuate._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 82, 1)
    __actuate._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 118, 2)
    
    actuate = property(__actuate.value, __actuate.set, None, None)

    _ElementMap.update({
        __DQ_AccuracyOfATimeMeasurement.name() : __DQ_AccuracyOfATimeMeasurement
    })
    _AttributeMap.update({
        __uuidref.name() : __uuidref,
        __nilReason.name() : __nilReason,
        __type.name() : __type,
        __href.name() : __href,
        __role.name() : __role,
        __arcrole.name() : __arcrole,
        __title.name() : __title,
        __show.name() : __show,
        __actuate.name() : __actuate
    })
_module_typeBindings.DQ_AccuracyOfATimeMeasurement_PropertyType = DQ_AccuracyOfATimeMeasurement_PropertyType
_Namespace_gmd.addCategoryObject('typeBinding', 'DQ_AccuracyOfATimeMeasurement_PropertyType', DQ_AccuracyOfATimeMeasurement_PropertyType)


# Complex type {http://www.isotc211.org/2005/gmd}DQ_QuantitativeAttributeAccuracy_PropertyType with content type ELEMENT_ONLY
class DQ_QuantitativeAttributeAccuracy_PropertyType (pyxb.binding.basis.complexTypeDefinition):
    """Complex type {http://www.isotc211.org/2005/gmd}DQ_QuantitativeAttributeAccuracy_PropertyType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'DQ_QuantitativeAttributeAccuracy_PropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 211, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.isotc211.org/2005/gmd}DQ_QuantitativeAttributeAccuracy uses Python identifier DQ_QuantitativeAttributeAccuracy
    __DQ_QuantitativeAttributeAccuracy = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'DQ_QuantitativeAttributeAccuracy'), 'DQ_QuantitativeAttributeAccuracy', '__httpwww_isotc211_org2005gmd_DQ_QuantitativeAttributeAccuracy_PropertyType_httpwww_isotc211_org2005gmdDQ_QuantitativeAttributeAccuracy', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 209, 1), )

    
    DQ_QuantitativeAttributeAccuracy = property(__DQ_QuantitativeAttributeAccuracy.value, __DQ_QuantitativeAttributeAccuracy.set, None, None)

    
    # Attribute uuidref uses Python identifier uuidref
    __uuidref = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'uuidref'), 'uuidref', '__httpwww_isotc211_org2005gmd_DQ_QuantitativeAttributeAccuracy_PropertyType_uuidref', pyxb.binding.datatypes.string)
    __uuidref._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 30, 2)
    __uuidref._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 30, 2)
    
    uuidref = property(__uuidref.value, __uuidref.set, None, None)

    
    # Attribute {http://www.isotc211.org/2005/gco}nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gco, 'nilReason'), 'nilReason', '__httpwww_isotc211_org2005gmd_DQ_QuantitativeAttributeAccuracy_PropertyType_httpwww_isotc211_org2005gconilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 33, 1)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 216, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}type uses Python identifier type
    __type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'type'), 'type', '__httpwww_isotc211_org2005gmd_DQ_QuantitativeAttributeAccuracy_PropertyType_httpwww_w3_org1999xlinktype', _ImportedBinding_bindings_v1411_write__xlink.typeType, fixed=True, unicode_default='simple')
    __type._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 29, 1)
    __type._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 112, 2)
    
    type = property(__type.value, __type.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}href uses Python identifier href
    __href = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'href'), 'href', '__httpwww_isotc211_org2005gmd_DQ_QuantitativeAttributeAccuracy_PropertyType_httpwww_w3_org1999xlinkhref', _ImportedBinding_bindings_v1411_write__xlink.hrefType)
    __href._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 42, 1)
    __href._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 113, 2)
    
    href = property(__href.value, __href.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}role uses Python identifier role
    __role = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'role'), 'role', '__httpwww_isotc211_org2005gmd_DQ_QuantitativeAttributeAccuracy_PropertyType_httpwww_w3_org1999xlinkrole', _ImportedBinding_bindings_v1411_write__xlink.roleType)
    __role._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 48, 1)
    __role._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 114, 2)
    
    role = property(__role.value, __role.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}arcrole uses Python identifier arcrole
    __arcrole = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'arcrole'), 'arcrole', '__httpwww_isotc211_org2005gmd_DQ_QuantitativeAttributeAccuracy_PropertyType_httpwww_w3_org1999xlinkarcrole', _ImportedBinding_bindings_v1411_write__xlink.arcroleType)
    __arcrole._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 56, 1)
    __arcrole._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 115, 2)
    
    arcrole = property(__arcrole.value, __arcrole.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}title uses Python identifier title
    __title = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'title'), 'title', '__httpwww_isotc211_org2005gmd_DQ_QuantitativeAttributeAccuracy_PropertyType_httpwww_w3_org1999xlinktitle', _ImportedBinding_bindings_v1411_write__xlink.titleAttrType)
    __title._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 64, 1)
    __title._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 116, 2)
    
    title = property(__title.value, __title.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}show uses Python identifier show
    __show = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'show'), 'show', '__httpwww_isotc211_org2005gmd_DQ_QuantitativeAttributeAccuracy_PropertyType_httpwww_w3_org1999xlinkshow', _ImportedBinding_bindings_v1411_write__xlink.showType)
    __show._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 70, 1)
    __show._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 117, 2)
    
    show = property(__show.value, __show.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}actuate uses Python identifier actuate
    __actuate = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'actuate'), 'actuate', '__httpwww_isotc211_org2005gmd_DQ_QuantitativeAttributeAccuracy_PropertyType_httpwww_w3_org1999xlinkactuate', _ImportedBinding_bindings_v1411_write__xlink.actuateType)
    __actuate._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 82, 1)
    __actuate._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 118, 2)
    
    actuate = property(__actuate.value, __actuate.set, None, None)

    _ElementMap.update({
        __DQ_QuantitativeAttributeAccuracy.name() : __DQ_QuantitativeAttributeAccuracy
    })
    _AttributeMap.update({
        __uuidref.name() : __uuidref,
        __nilReason.name() : __nilReason,
        __type.name() : __type,
        __href.name() : __href,
        __role.name() : __role,
        __arcrole.name() : __arcrole,
        __title.name() : __title,
        __show.name() : __show,
        __actuate.name() : __actuate
    })
_module_typeBindings.DQ_QuantitativeAttributeAccuracy_PropertyType = DQ_QuantitativeAttributeAccuracy_PropertyType
_Namespace_gmd.addCategoryObject('typeBinding', 'DQ_QuantitativeAttributeAccuracy_PropertyType', DQ_QuantitativeAttributeAccuracy_PropertyType)


# Complex type {http://www.isotc211.org/2005/gmd}DQ_NonQuantitativeAttributeAccuracy_PropertyType with content type ELEMENT_ONLY
class DQ_NonQuantitativeAttributeAccuracy_PropertyType (pyxb.binding.basis.complexTypeDefinition):
    """Complex type {http://www.isotc211.org/2005/gmd}DQ_NonQuantitativeAttributeAccuracy_PropertyType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'DQ_NonQuantitativeAttributeAccuracy_PropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 227, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.isotc211.org/2005/gmd}DQ_NonQuantitativeAttributeAccuracy uses Python identifier DQ_NonQuantitativeAttributeAccuracy
    __DQ_NonQuantitativeAttributeAccuracy = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'DQ_NonQuantitativeAttributeAccuracy'), 'DQ_NonQuantitativeAttributeAccuracy', '__httpwww_isotc211_org2005gmd_DQ_NonQuantitativeAttributeAccuracy_PropertyType_httpwww_isotc211_org2005gmdDQ_NonQuantitativeAttributeAccuracy', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 225, 1), )

    
    DQ_NonQuantitativeAttributeAccuracy = property(__DQ_NonQuantitativeAttributeAccuracy.value, __DQ_NonQuantitativeAttributeAccuracy.set, None, None)

    
    # Attribute uuidref uses Python identifier uuidref
    __uuidref = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'uuidref'), 'uuidref', '__httpwww_isotc211_org2005gmd_DQ_NonQuantitativeAttributeAccuracy_PropertyType_uuidref', pyxb.binding.datatypes.string)
    __uuidref._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 30, 2)
    __uuidref._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 30, 2)
    
    uuidref = property(__uuidref.value, __uuidref.set, None, None)

    
    # Attribute {http://www.isotc211.org/2005/gco}nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gco, 'nilReason'), 'nilReason', '__httpwww_isotc211_org2005gmd_DQ_NonQuantitativeAttributeAccuracy_PropertyType_httpwww_isotc211_org2005gconilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 33, 1)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 232, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}type uses Python identifier type
    __type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'type'), 'type', '__httpwww_isotc211_org2005gmd_DQ_NonQuantitativeAttributeAccuracy_PropertyType_httpwww_w3_org1999xlinktype', _ImportedBinding_bindings_v1411_write__xlink.typeType, fixed=True, unicode_default='simple')
    __type._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 29, 1)
    __type._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 112, 2)
    
    type = property(__type.value, __type.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}href uses Python identifier href
    __href = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'href'), 'href', '__httpwww_isotc211_org2005gmd_DQ_NonQuantitativeAttributeAccuracy_PropertyType_httpwww_w3_org1999xlinkhref', _ImportedBinding_bindings_v1411_write__xlink.hrefType)
    __href._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 42, 1)
    __href._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 113, 2)
    
    href = property(__href.value, __href.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}role uses Python identifier role
    __role = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'role'), 'role', '__httpwww_isotc211_org2005gmd_DQ_NonQuantitativeAttributeAccuracy_PropertyType_httpwww_w3_org1999xlinkrole', _ImportedBinding_bindings_v1411_write__xlink.roleType)
    __role._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 48, 1)
    __role._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 114, 2)
    
    role = property(__role.value, __role.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}arcrole uses Python identifier arcrole
    __arcrole = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'arcrole'), 'arcrole', '__httpwww_isotc211_org2005gmd_DQ_NonQuantitativeAttributeAccuracy_PropertyType_httpwww_w3_org1999xlinkarcrole', _ImportedBinding_bindings_v1411_write__xlink.arcroleType)
    __arcrole._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 56, 1)
    __arcrole._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 115, 2)
    
    arcrole = property(__arcrole.value, __arcrole.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}title uses Python identifier title
    __title = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'title'), 'title', '__httpwww_isotc211_org2005gmd_DQ_NonQuantitativeAttributeAccuracy_PropertyType_httpwww_w3_org1999xlinktitle', _ImportedBinding_bindings_v1411_write__xlink.titleAttrType)
    __title._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 64, 1)
    __title._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 116, 2)
    
    title = property(__title.value, __title.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}show uses Python identifier show
    __show = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'show'), 'show', '__httpwww_isotc211_org2005gmd_DQ_NonQuantitativeAttributeAccuracy_PropertyType_httpwww_w3_org1999xlinkshow', _ImportedBinding_bindings_v1411_write__xlink.showType)
    __show._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 70, 1)
    __show._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 117, 2)
    
    show = property(__show.value, __show.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}actuate uses Python identifier actuate
    __actuate = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'actuate'), 'actuate', '__httpwww_isotc211_org2005gmd_DQ_NonQuantitativeAttributeAccuracy_PropertyType_httpwww_w3_org1999xlinkactuate', _ImportedBinding_bindings_v1411_write__xlink.actuateType)
    __actuate._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 82, 1)
    __actuate._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 118, 2)
    
    actuate = property(__actuate.value, __actuate.set, None, None)

    _ElementMap.update({
        __DQ_NonQuantitativeAttributeAccuracy.name() : __DQ_NonQuantitativeAttributeAccuracy
    })
    _AttributeMap.update({
        __uuidref.name() : __uuidref,
        __nilReason.name() : __nilReason,
        __type.name() : __type,
        __href.name() : __href,
        __role.name() : __role,
        __arcrole.name() : __arcrole,
        __title.name() : __title,
        __show.name() : __show,
        __actuate.name() : __actuate
    })
_module_typeBindings.DQ_NonQuantitativeAttributeAccuracy_PropertyType = DQ_NonQuantitativeAttributeAccuracy_PropertyType
_Namespace_gmd.addCategoryObject('typeBinding', 'DQ_NonQuantitativeAttributeAccuracy_PropertyType', DQ_NonQuantitativeAttributeAccuracy_PropertyType)


# Complex type {http://www.isotc211.org/2005/gmd}DQ_ThematicClassificationCorrectness_PropertyType with content type ELEMENT_ONLY
class DQ_ThematicClassificationCorrectness_PropertyType (pyxb.binding.basis.complexTypeDefinition):
    """Complex type {http://www.isotc211.org/2005/gmd}DQ_ThematicClassificationCorrectness_PropertyType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'DQ_ThematicClassificationCorrectness_PropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 243, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.isotc211.org/2005/gmd}DQ_ThematicClassificationCorrectness uses Python identifier DQ_ThematicClassificationCorrectness
    __DQ_ThematicClassificationCorrectness = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'DQ_ThematicClassificationCorrectness'), 'DQ_ThematicClassificationCorrectness', '__httpwww_isotc211_org2005gmd_DQ_ThematicClassificationCorrectness_PropertyType_httpwww_isotc211_org2005gmdDQ_ThematicClassificationCorrectness', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 241, 1), )

    
    DQ_ThematicClassificationCorrectness = property(__DQ_ThematicClassificationCorrectness.value, __DQ_ThematicClassificationCorrectness.set, None, None)

    
    # Attribute uuidref uses Python identifier uuidref
    __uuidref = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'uuidref'), 'uuidref', '__httpwww_isotc211_org2005gmd_DQ_ThematicClassificationCorrectness_PropertyType_uuidref', pyxb.binding.datatypes.string)
    __uuidref._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 30, 2)
    __uuidref._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 30, 2)
    
    uuidref = property(__uuidref.value, __uuidref.set, None, None)

    
    # Attribute {http://www.isotc211.org/2005/gco}nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gco, 'nilReason'), 'nilReason', '__httpwww_isotc211_org2005gmd_DQ_ThematicClassificationCorrectness_PropertyType_httpwww_isotc211_org2005gconilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 33, 1)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 248, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}type uses Python identifier type
    __type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'type'), 'type', '__httpwww_isotc211_org2005gmd_DQ_ThematicClassificationCorrectness_PropertyType_httpwww_w3_org1999xlinktype', _ImportedBinding_bindings_v1411_write__xlink.typeType, fixed=True, unicode_default='simple')
    __type._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 29, 1)
    __type._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 112, 2)
    
    type = property(__type.value, __type.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}href uses Python identifier href
    __href = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'href'), 'href', '__httpwww_isotc211_org2005gmd_DQ_ThematicClassificationCorrectness_PropertyType_httpwww_w3_org1999xlinkhref', _ImportedBinding_bindings_v1411_write__xlink.hrefType)
    __href._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 42, 1)
    __href._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 113, 2)
    
    href = property(__href.value, __href.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}role uses Python identifier role
    __role = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'role'), 'role', '__httpwww_isotc211_org2005gmd_DQ_ThematicClassificationCorrectness_PropertyType_httpwww_w3_org1999xlinkrole', _ImportedBinding_bindings_v1411_write__xlink.roleType)
    __role._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 48, 1)
    __role._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 114, 2)
    
    role = property(__role.value, __role.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}arcrole uses Python identifier arcrole
    __arcrole = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'arcrole'), 'arcrole', '__httpwww_isotc211_org2005gmd_DQ_ThematicClassificationCorrectness_PropertyType_httpwww_w3_org1999xlinkarcrole', _ImportedBinding_bindings_v1411_write__xlink.arcroleType)
    __arcrole._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 56, 1)
    __arcrole._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 115, 2)
    
    arcrole = property(__arcrole.value, __arcrole.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}title uses Python identifier title
    __title = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'title'), 'title', '__httpwww_isotc211_org2005gmd_DQ_ThematicClassificationCorrectness_PropertyType_httpwww_w3_org1999xlinktitle', _ImportedBinding_bindings_v1411_write__xlink.titleAttrType)
    __title._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 64, 1)
    __title._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 116, 2)
    
    title = property(__title.value, __title.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}show uses Python identifier show
    __show = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'show'), 'show', '__httpwww_isotc211_org2005gmd_DQ_ThematicClassificationCorrectness_PropertyType_httpwww_w3_org1999xlinkshow', _ImportedBinding_bindings_v1411_write__xlink.showType)
    __show._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 70, 1)
    __show._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 117, 2)
    
    show = property(__show.value, __show.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}actuate uses Python identifier actuate
    __actuate = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'actuate'), 'actuate', '__httpwww_isotc211_org2005gmd_DQ_ThematicClassificationCorrectness_PropertyType_httpwww_w3_org1999xlinkactuate', _ImportedBinding_bindings_v1411_write__xlink.actuateType)
    __actuate._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 82, 1)
    __actuate._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 118, 2)
    
    actuate = property(__actuate.value, __actuate.set, None, None)

    _ElementMap.update({
        __DQ_ThematicClassificationCorrectness.name() : __DQ_ThematicClassificationCorrectness
    })
    _AttributeMap.update({
        __uuidref.name() : __uuidref,
        __nilReason.name() : __nilReason,
        __type.name() : __type,
        __href.name() : __href,
        __role.name() : __role,
        __arcrole.name() : __arcrole,
        __title.name() : __title,
        __show.name() : __show,
        __actuate.name() : __actuate
    })
_module_typeBindings.DQ_ThematicClassificationCorrectness_PropertyType = DQ_ThematicClassificationCorrectness_PropertyType
_Namespace_gmd.addCategoryObject('typeBinding', 'DQ_ThematicClassificationCorrectness_PropertyType', DQ_ThematicClassificationCorrectness_PropertyType)


# Complex type {http://www.isotc211.org/2005/gmd}DQ_RelativeInternalPositionalAccuracy_PropertyType with content type ELEMENT_ONLY
class DQ_RelativeInternalPositionalAccuracy_PropertyType (pyxb.binding.basis.complexTypeDefinition):
    """Complex type {http://www.isotc211.org/2005/gmd}DQ_RelativeInternalPositionalAccuracy_PropertyType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'DQ_RelativeInternalPositionalAccuracy_PropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 259, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.isotc211.org/2005/gmd}DQ_RelativeInternalPositionalAccuracy uses Python identifier DQ_RelativeInternalPositionalAccuracy
    __DQ_RelativeInternalPositionalAccuracy = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'DQ_RelativeInternalPositionalAccuracy'), 'DQ_RelativeInternalPositionalAccuracy', '__httpwww_isotc211_org2005gmd_DQ_RelativeInternalPositionalAccuracy_PropertyType_httpwww_isotc211_org2005gmdDQ_RelativeInternalPositionalAccuracy', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 257, 1), )

    
    DQ_RelativeInternalPositionalAccuracy = property(__DQ_RelativeInternalPositionalAccuracy.value, __DQ_RelativeInternalPositionalAccuracy.set, None, None)

    
    # Attribute uuidref uses Python identifier uuidref
    __uuidref = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'uuidref'), 'uuidref', '__httpwww_isotc211_org2005gmd_DQ_RelativeInternalPositionalAccuracy_PropertyType_uuidref', pyxb.binding.datatypes.string)
    __uuidref._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 30, 2)
    __uuidref._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 30, 2)
    
    uuidref = property(__uuidref.value, __uuidref.set, None, None)

    
    # Attribute {http://www.isotc211.org/2005/gco}nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gco, 'nilReason'), 'nilReason', '__httpwww_isotc211_org2005gmd_DQ_RelativeInternalPositionalAccuracy_PropertyType_httpwww_isotc211_org2005gconilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 33, 1)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 264, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}type uses Python identifier type
    __type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'type'), 'type', '__httpwww_isotc211_org2005gmd_DQ_RelativeInternalPositionalAccuracy_PropertyType_httpwww_w3_org1999xlinktype', _ImportedBinding_bindings_v1411_write__xlink.typeType, fixed=True, unicode_default='simple')
    __type._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 29, 1)
    __type._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 112, 2)
    
    type = property(__type.value, __type.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}href uses Python identifier href
    __href = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'href'), 'href', '__httpwww_isotc211_org2005gmd_DQ_RelativeInternalPositionalAccuracy_PropertyType_httpwww_w3_org1999xlinkhref', _ImportedBinding_bindings_v1411_write__xlink.hrefType)
    __href._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 42, 1)
    __href._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 113, 2)
    
    href = property(__href.value, __href.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}role uses Python identifier role
    __role = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'role'), 'role', '__httpwww_isotc211_org2005gmd_DQ_RelativeInternalPositionalAccuracy_PropertyType_httpwww_w3_org1999xlinkrole', _ImportedBinding_bindings_v1411_write__xlink.roleType)
    __role._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 48, 1)
    __role._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 114, 2)
    
    role = property(__role.value, __role.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}arcrole uses Python identifier arcrole
    __arcrole = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'arcrole'), 'arcrole', '__httpwww_isotc211_org2005gmd_DQ_RelativeInternalPositionalAccuracy_PropertyType_httpwww_w3_org1999xlinkarcrole', _ImportedBinding_bindings_v1411_write__xlink.arcroleType)
    __arcrole._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 56, 1)
    __arcrole._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 115, 2)
    
    arcrole = property(__arcrole.value, __arcrole.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}title uses Python identifier title
    __title = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'title'), 'title', '__httpwww_isotc211_org2005gmd_DQ_RelativeInternalPositionalAccuracy_PropertyType_httpwww_w3_org1999xlinktitle', _ImportedBinding_bindings_v1411_write__xlink.titleAttrType)
    __title._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 64, 1)
    __title._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 116, 2)
    
    title = property(__title.value, __title.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}show uses Python identifier show
    __show = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'show'), 'show', '__httpwww_isotc211_org2005gmd_DQ_RelativeInternalPositionalAccuracy_PropertyType_httpwww_w3_org1999xlinkshow', _ImportedBinding_bindings_v1411_write__xlink.showType)
    __show._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 70, 1)
    __show._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 117, 2)
    
    show = property(__show.value, __show.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}actuate uses Python identifier actuate
    __actuate = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'actuate'), 'actuate', '__httpwww_isotc211_org2005gmd_DQ_RelativeInternalPositionalAccuracy_PropertyType_httpwww_w3_org1999xlinkactuate', _ImportedBinding_bindings_v1411_write__xlink.actuateType)
    __actuate._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 82, 1)
    __actuate._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 118, 2)
    
    actuate = property(__actuate.value, __actuate.set, None, None)

    _ElementMap.update({
        __DQ_RelativeInternalPositionalAccuracy.name() : __DQ_RelativeInternalPositionalAccuracy
    })
    _AttributeMap.update({
        __uuidref.name() : __uuidref,
        __nilReason.name() : __nilReason,
        __type.name() : __type,
        __href.name() : __href,
        __role.name() : __role,
        __arcrole.name() : __arcrole,
        __title.name() : __title,
        __show.name() : __show,
        __actuate.name() : __actuate
    })
_module_typeBindings.DQ_RelativeInternalPositionalAccuracy_PropertyType = DQ_RelativeInternalPositionalAccuracy_PropertyType
_Namespace_gmd.addCategoryObject('typeBinding', 'DQ_RelativeInternalPositionalAccuracy_PropertyType', DQ_RelativeInternalPositionalAccuracy_PropertyType)


# Complex type {http://www.isotc211.org/2005/gmd}DQ_GriddedDataPositionalAccuracy_PropertyType with content type ELEMENT_ONLY
class DQ_GriddedDataPositionalAccuracy_PropertyType (pyxb.binding.basis.complexTypeDefinition):
    """Complex type {http://www.isotc211.org/2005/gmd}DQ_GriddedDataPositionalAccuracy_PropertyType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'DQ_GriddedDataPositionalAccuracy_PropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 275, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.isotc211.org/2005/gmd}DQ_GriddedDataPositionalAccuracy uses Python identifier DQ_GriddedDataPositionalAccuracy
    __DQ_GriddedDataPositionalAccuracy = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'DQ_GriddedDataPositionalAccuracy'), 'DQ_GriddedDataPositionalAccuracy', '__httpwww_isotc211_org2005gmd_DQ_GriddedDataPositionalAccuracy_PropertyType_httpwww_isotc211_org2005gmdDQ_GriddedDataPositionalAccuracy', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 273, 1), )

    
    DQ_GriddedDataPositionalAccuracy = property(__DQ_GriddedDataPositionalAccuracy.value, __DQ_GriddedDataPositionalAccuracy.set, None, None)

    
    # Attribute uuidref uses Python identifier uuidref
    __uuidref = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'uuidref'), 'uuidref', '__httpwww_isotc211_org2005gmd_DQ_GriddedDataPositionalAccuracy_PropertyType_uuidref', pyxb.binding.datatypes.string)
    __uuidref._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 30, 2)
    __uuidref._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 30, 2)
    
    uuidref = property(__uuidref.value, __uuidref.set, None, None)

    
    # Attribute {http://www.isotc211.org/2005/gco}nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gco, 'nilReason'), 'nilReason', '__httpwww_isotc211_org2005gmd_DQ_GriddedDataPositionalAccuracy_PropertyType_httpwww_isotc211_org2005gconilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 33, 1)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 280, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}type uses Python identifier type
    __type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'type'), 'type', '__httpwww_isotc211_org2005gmd_DQ_GriddedDataPositionalAccuracy_PropertyType_httpwww_w3_org1999xlinktype', _ImportedBinding_bindings_v1411_write__xlink.typeType, fixed=True, unicode_default='simple')
    __type._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 29, 1)
    __type._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 112, 2)
    
    type = property(__type.value, __type.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}href uses Python identifier href
    __href = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'href'), 'href', '__httpwww_isotc211_org2005gmd_DQ_GriddedDataPositionalAccuracy_PropertyType_httpwww_w3_org1999xlinkhref', _ImportedBinding_bindings_v1411_write__xlink.hrefType)
    __href._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 42, 1)
    __href._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 113, 2)
    
    href = property(__href.value, __href.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}role uses Python identifier role
    __role = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'role'), 'role', '__httpwww_isotc211_org2005gmd_DQ_GriddedDataPositionalAccuracy_PropertyType_httpwww_w3_org1999xlinkrole', _ImportedBinding_bindings_v1411_write__xlink.roleType)
    __role._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 48, 1)
    __role._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 114, 2)
    
    role = property(__role.value, __role.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}arcrole uses Python identifier arcrole
    __arcrole = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'arcrole'), 'arcrole', '__httpwww_isotc211_org2005gmd_DQ_GriddedDataPositionalAccuracy_PropertyType_httpwww_w3_org1999xlinkarcrole', _ImportedBinding_bindings_v1411_write__xlink.arcroleType)
    __arcrole._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 56, 1)
    __arcrole._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 115, 2)
    
    arcrole = property(__arcrole.value, __arcrole.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}title uses Python identifier title
    __title = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'title'), 'title', '__httpwww_isotc211_org2005gmd_DQ_GriddedDataPositionalAccuracy_PropertyType_httpwww_w3_org1999xlinktitle', _ImportedBinding_bindings_v1411_write__xlink.titleAttrType)
    __title._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 64, 1)
    __title._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 116, 2)
    
    title = property(__title.value, __title.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}show uses Python identifier show
    __show = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'show'), 'show', '__httpwww_isotc211_org2005gmd_DQ_GriddedDataPositionalAccuracy_PropertyType_httpwww_w3_org1999xlinkshow', _ImportedBinding_bindings_v1411_write__xlink.showType)
    __show._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 70, 1)
    __show._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 117, 2)
    
    show = property(__show.value, __show.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}actuate uses Python identifier actuate
    __actuate = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'actuate'), 'actuate', '__httpwww_isotc211_org2005gmd_DQ_GriddedDataPositionalAccuracy_PropertyType_httpwww_w3_org1999xlinkactuate', _ImportedBinding_bindings_v1411_write__xlink.actuateType)
    __actuate._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 82, 1)
    __actuate._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 118, 2)
    
    actuate = property(__actuate.value, __actuate.set, None, None)

    _ElementMap.update({
        __DQ_GriddedDataPositionalAccuracy.name() : __DQ_GriddedDataPositionalAccuracy
    })
    _AttributeMap.update({
        __uuidref.name() : __uuidref,
        __nilReason.name() : __nilReason,
        __type.name() : __type,
        __href.name() : __href,
        __role.name() : __role,
        __arcrole.name() : __arcrole,
        __title.name() : __title,
        __show.name() : __show,
        __actuate.name() : __actuate
    })
_module_typeBindings.DQ_GriddedDataPositionalAccuracy_PropertyType = DQ_GriddedDataPositionalAccuracy_PropertyType
_Namespace_gmd.addCategoryObject('typeBinding', 'DQ_GriddedDataPositionalAccuracy_PropertyType', DQ_GriddedDataPositionalAccuracy_PropertyType)


# Complex type {http://www.isotc211.org/2005/gmd}DQ_AbsoluteExternalPositionalAccuracy_PropertyType with content type ELEMENT_ONLY
class DQ_AbsoluteExternalPositionalAccuracy_PropertyType (pyxb.binding.basis.complexTypeDefinition):
    """Complex type {http://www.isotc211.org/2005/gmd}DQ_AbsoluteExternalPositionalAccuracy_PropertyType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'DQ_AbsoluteExternalPositionalAccuracy_PropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 291, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.isotc211.org/2005/gmd}DQ_AbsoluteExternalPositionalAccuracy uses Python identifier DQ_AbsoluteExternalPositionalAccuracy
    __DQ_AbsoluteExternalPositionalAccuracy = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'DQ_AbsoluteExternalPositionalAccuracy'), 'DQ_AbsoluteExternalPositionalAccuracy', '__httpwww_isotc211_org2005gmd_DQ_AbsoluteExternalPositionalAccuracy_PropertyType_httpwww_isotc211_org2005gmdDQ_AbsoluteExternalPositionalAccuracy', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 289, 1), )

    
    DQ_AbsoluteExternalPositionalAccuracy = property(__DQ_AbsoluteExternalPositionalAccuracy.value, __DQ_AbsoluteExternalPositionalAccuracy.set, None, None)

    
    # Attribute uuidref uses Python identifier uuidref
    __uuidref = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'uuidref'), 'uuidref', '__httpwww_isotc211_org2005gmd_DQ_AbsoluteExternalPositionalAccuracy_PropertyType_uuidref', pyxb.binding.datatypes.string)
    __uuidref._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 30, 2)
    __uuidref._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 30, 2)
    
    uuidref = property(__uuidref.value, __uuidref.set, None, None)

    
    # Attribute {http://www.isotc211.org/2005/gco}nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gco, 'nilReason'), 'nilReason', '__httpwww_isotc211_org2005gmd_DQ_AbsoluteExternalPositionalAccuracy_PropertyType_httpwww_isotc211_org2005gconilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 33, 1)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 296, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}type uses Python identifier type
    __type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'type'), 'type', '__httpwww_isotc211_org2005gmd_DQ_AbsoluteExternalPositionalAccuracy_PropertyType_httpwww_w3_org1999xlinktype', _ImportedBinding_bindings_v1411_write__xlink.typeType, fixed=True, unicode_default='simple')
    __type._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 29, 1)
    __type._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 112, 2)
    
    type = property(__type.value, __type.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}href uses Python identifier href
    __href = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'href'), 'href', '__httpwww_isotc211_org2005gmd_DQ_AbsoluteExternalPositionalAccuracy_PropertyType_httpwww_w3_org1999xlinkhref', _ImportedBinding_bindings_v1411_write__xlink.hrefType)
    __href._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 42, 1)
    __href._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 113, 2)
    
    href = property(__href.value, __href.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}role uses Python identifier role
    __role = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'role'), 'role', '__httpwww_isotc211_org2005gmd_DQ_AbsoluteExternalPositionalAccuracy_PropertyType_httpwww_w3_org1999xlinkrole', _ImportedBinding_bindings_v1411_write__xlink.roleType)
    __role._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 48, 1)
    __role._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 114, 2)
    
    role = property(__role.value, __role.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}arcrole uses Python identifier arcrole
    __arcrole = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'arcrole'), 'arcrole', '__httpwww_isotc211_org2005gmd_DQ_AbsoluteExternalPositionalAccuracy_PropertyType_httpwww_w3_org1999xlinkarcrole', _ImportedBinding_bindings_v1411_write__xlink.arcroleType)
    __arcrole._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 56, 1)
    __arcrole._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 115, 2)
    
    arcrole = property(__arcrole.value, __arcrole.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}title uses Python identifier title
    __title = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'title'), 'title', '__httpwww_isotc211_org2005gmd_DQ_AbsoluteExternalPositionalAccuracy_PropertyType_httpwww_w3_org1999xlinktitle', _ImportedBinding_bindings_v1411_write__xlink.titleAttrType)
    __title._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 64, 1)
    __title._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 116, 2)
    
    title = property(__title.value, __title.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}show uses Python identifier show
    __show = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'show'), 'show', '__httpwww_isotc211_org2005gmd_DQ_AbsoluteExternalPositionalAccuracy_PropertyType_httpwww_w3_org1999xlinkshow', _ImportedBinding_bindings_v1411_write__xlink.showType)
    __show._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 70, 1)
    __show._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 117, 2)
    
    show = property(__show.value, __show.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}actuate uses Python identifier actuate
    __actuate = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'actuate'), 'actuate', '__httpwww_isotc211_org2005gmd_DQ_AbsoluteExternalPositionalAccuracy_PropertyType_httpwww_w3_org1999xlinkactuate', _ImportedBinding_bindings_v1411_write__xlink.actuateType)
    __actuate._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 82, 1)
    __actuate._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 118, 2)
    
    actuate = property(__actuate.value, __actuate.set, None, None)

    _ElementMap.update({
        __DQ_AbsoluteExternalPositionalAccuracy.name() : __DQ_AbsoluteExternalPositionalAccuracy
    })
    _AttributeMap.update({
        __uuidref.name() : __uuidref,
        __nilReason.name() : __nilReason,
        __type.name() : __type,
        __href.name() : __href,
        __role.name() : __role,
        __arcrole.name() : __arcrole,
        __title.name() : __title,
        __show.name() : __show,
        __actuate.name() : __actuate
    })
_module_typeBindings.DQ_AbsoluteExternalPositionalAccuracy_PropertyType = DQ_AbsoluteExternalPositionalAccuracy_PropertyType
_Namespace_gmd.addCategoryObject('typeBinding', 'DQ_AbsoluteExternalPositionalAccuracy_PropertyType', DQ_AbsoluteExternalPositionalAccuracy_PropertyType)


# Complex type {http://www.isotc211.org/2005/gmd}DQ_TopologicalConsistency_PropertyType with content type ELEMENT_ONLY
class DQ_TopologicalConsistency_PropertyType (pyxb.binding.basis.complexTypeDefinition):
    """Complex type {http://www.isotc211.org/2005/gmd}DQ_TopologicalConsistency_PropertyType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'DQ_TopologicalConsistency_PropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 307, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.isotc211.org/2005/gmd}DQ_TopologicalConsistency uses Python identifier DQ_TopologicalConsistency
    __DQ_TopologicalConsistency = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'DQ_TopologicalConsistency'), 'DQ_TopologicalConsistency', '__httpwww_isotc211_org2005gmd_DQ_TopologicalConsistency_PropertyType_httpwww_isotc211_org2005gmdDQ_TopologicalConsistency', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 305, 1), )

    
    DQ_TopologicalConsistency = property(__DQ_TopologicalConsistency.value, __DQ_TopologicalConsistency.set, None, None)

    
    # Attribute uuidref uses Python identifier uuidref
    __uuidref = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'uuidref'), 'uuidref', '__httpwww_isotc211_org2005gmd_DQ_TopologicalConsistency_PropertyType_uuidref', pyxb.binding.datatypes.string)
    __uuidref._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 30, 2)
    __uuidref._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 30, 2)
    
    uuidref = property(__uuidref.value, __uuidref.set, None, None)

    
    # Attribute {http://www.isotc211.org/2005/gco}nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gco, 'nilReason'), 'nilReason', '__httpwww_isotc211_org2005gmd_DQ_TopologicalConsistency_PropertyType_httpwww_isotc211_org2005gconilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 33, 1)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 312, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}type uses Python identifier type
    __type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'type'), 'type', '__httpwww_isotc211_org2005gmd_DQ_TopologicalConsistency_PropertyType_httpwww_w3_org1999xlinktype', _ImportedBinding_bindings_v1411_write__xlink.typeType, fixed=True, unicode_default='simple')
    __type._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 29, 1)
    __type._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 112, 2)
    
    type = property(__type.value, __type.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}href uses Python identifier href
    __href = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'href'), 'href', '__httpwww_isotc211_org2005gmd_DQ_TopologicalConsistency_PropertyType_httpwww_w3_org1999xlinkhref', _ImportedBinding_bindings_v1411_write__xlink.hrefType)
    __href._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 42, 1)
    __href._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 113, 2)
    
    href = property(__href.value, __href.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}role uses Python identifier role
    __role = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'role'), 'role', '__httpwww_isotc211_org2005gmd_DQ_TopologicalConsistency_PropertyType_httpwww_w3_org1999xlinkrole', _ImportedBinding_bindings_v1411_write__xlink.roleType)
    __role._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 48, 1)
    __role._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 114, 2)
    
    role = property(__role.value, __role.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}arcrole uses Python identifier arcrole
    __arcrole = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'arcrole'), 'arcrole', '__httpwww_isotc211_org2005gmd_DQ_TopologicalConsistency_PropertyType_httpwww_w3_org1999xlinkarcrole', _ImportedBinding_bindings_v1411_write__xlink.arcroleType)
    __arcrole._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 56, 1)
    __arcrole._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 115, 2)
    
    arcrole = property(__arcrole.value, __arcrole.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}title uses Python identifier title
    __title = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'title'), 'title', '__httpwww_isotc211_org2005gmd_DQ_TopologicalConsistency_PropertyType_httpwww_w3_org1999xlinktitle', _ImportedBinding_bindings_v1411_write__xlink.titleAttrType)
    __title._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 64, 1)
    __title._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 116, 2)
    
    title = property(__title.value, __title.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}show uses Python identifier show
    __show = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'show'), 'show', '__httpwww_isotc211_org2005gmd_DQ_TopologicalConsistency_PropertyType_httpwww_w3_org1999xlinkshow', _ImportedBinding_bindings_v1411_write__xlink.showType)
    __show._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 70, 1)
    __show._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 117, 2)
    
    show = property(__show.value, __show.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}actuate uses Python identifier actuate
    __actuate = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'actuate'), 'actuate', '__httpwww_isotc211_org2005gmd_DQ_TopologicalConsistency_PropertyType_httpwww_w3_org1999xlinkactuate', _ImportedBinding_bindings_v1411_write__xlink.actuateType)
    __actuate._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 82, 1)
    __actuate._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 118, 2)
    
    actuate = property(__actuate.value, __actuate.set, None, None)

    _ElementMap.update({
        __DQ_TopologicalConsistency.name() : __DQ_TopologicalConsistency
    })
    _AttributeMap.update({
        __uuidref.name() : __uuidref,
        __nilReason.name() : __nilReason,
        __type.name() : __type,
        __href.name() : __href,
        __role.name() : __role,
        __arcrole.name() : __arcrole,
        __title.name() : __title,
        __show.name() : __show,
        __actuate.name() : __actuate
    })
_module_typeBindings.DQ_TopologicalConsistency_PropertyType = DQ_TopologicalConsistency_PropertyType
_Namespace_gmd.addCategoryObject('typeBinding', 'DQ_TopologicalConsistency_PropertyType', DQ_TopologicalConsistency_PropertyType)


# Complex type {http://www.isotc211.org/2005/gmd}DQ_FormatConsistency_PropertyType with content type ELEMENT_ONLY
class DQ_FormatConsistency_PropertyType (pyxb.binding.basis.complexTypeDefinition):
    """Complex type {http://www.isotc211.org/2005/gmd}DQ_FormatConsistency_PropertyType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'DQ_FormatConsistency_PropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 323, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.isotc211.org/2005/gmd}DQ_FormatConsistency uses Python identifier DQ_FormatConsistency
    __DQ_FormatConsistency = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'DQ_FormatConsistency'), 'DQ_FormatConsistency', '__httpwww_isotc211_org2005gmd_DQ_FormatConsistency_PropertyType_httpwww_isotc211_org2005gmdDQ_FormatConsistency', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 321, 1), )

    
    DQ_FormatConsistency = property(__DQ_FormatConsistency.value, __DQ_FormatConsistency.set, None, None)

    
    # Attribute uuidref uses Python identifier uuidref
    __uuidref = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'uuidref'), 'uuidref', '__httpwww_isotc211_org2005gmd_DQ_FormatConsistency_PropertyType_uuidref', pyxb.binding.datatypes.string)
    __uuidref._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 30, 2)
    __uuidref._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 30, 2)
    
    uuidref = property(__uuidref.value, __uuidref.set, None, None)

    
    # Attribute {http://www.isotc211.org/2005/gco}nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gco, 'nilReason'), 'nilReason', '__httpwww_isotc211_org2005gmd_DQ_FormatConsistency_PropertyType_httpwww_isotc211_org2005gconilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 33, 1)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 328, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}type uses Python identifier type
    __type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'type'), 'type', '__httpwww_isotc211_org2005gmd_DQ_FormatConsistency_PropertyType_httpwww_w3_org1999xlinktype', _ImportedBinding_bindings_v1411_write__xlink.typeType, fixed=True, unicode_default='simple')
    __type._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 29, 1)
    __type._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 112, 2)
    
    type = property(__type.value, __type.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}href uses Python identifier href
    __href = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'href'), 'href', '__httpwww_isotc211_org2005gmd_DQ_FormatConsistency_PropertyType_httpwww_w3_org1999xlinkhref', _ImportedBinding_bindings_v1411_write__xlink.hrefType)
    __href._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 42, 1)
    __href._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 113, 2)
    
    href = property(__href.value, __href.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}role uses Python identifier role
    __role = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'role'), 'role', '__httpwww_isotc211_org2005gmd_DQ_FormatConsistency_PropertyType_httpwww_w3_org1999xlinkrole', _ImportedBinding_bindings_v1411_write__xlink.roleType)
    __role._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 48, 1)
    __role._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 114, 2)
    
    role = property(__role.value, __role.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}arcrole uses Python identifier arcrole
    __arcrole = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'arcrole'), 'arcrole', '__httpwww_isotc211_org2005gmd_DQ_FormatConsistency_PropertyType_httpwww_w3_org1999xlinkarcrole', _ImportedBinding_bindings_v1411_write__xlink.arcroleType)
    __arcrole._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 56, 1)
    __arcrole._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 115, 2)
    
    arcrole = property(__arcrole.value, __arcrole.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}title uses Python identifier title
    __title = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'title'), 'title', '__httpwww_isotc211_org2005gmd_DQ_FormatConsistency_PropertyType_httpwww_w3_org1999xlinktitle', _ImportedBinding_bindings_v1411_write__xlink.titleAttrType)
    __title._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 64, 1)
    __title._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 116, 2)
    
    title = property(__title.value, __title.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}show uses Python identifier show
    __show = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'show'), 'show', '__httpwww_isotc211_org2005gmd_DQ_FormatConsistency_PropertyType_httpwww_w3_org1999xlinkshow', _ImportedBinding_bindings_v1411_write__xlink.showType)
    __show._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 70, 1)
    __show._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 117, 2)
    
    show = property(__show.value, __show.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}actuate uses Python identifier actuate
    __actuate = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'actuate'), 'actuate', '__httpwww_isotc211_org2005gmd_DQ_FormatConsistency_PropertyType_httpwww_w3_org1999xlinkactuate', _ImportedBinding_bindings_v1411_write__xlink.actuateType)
    __actuate._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 82, 1)
    __actuate._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 118, 2)
    
    actuate = property(__actuate.value, __actuate.set, None, None)

    _ElementMap.update({
        __DQ_FormatConsistency.name() : __DQ_FormatConsistency
    })
    _AttributeMap.update({
        __uuidref.name() : __uuidref,
        __nilReason.name() : __nilReason,
        __type.name() : __type,
        __href.name() : __href,
        __role.name() : __role,
        __arcrole.name() : __arcrole,
        __title.name() : __title,
        __show.name() : __show,
        __actuate.name() : __actuate
    })
_module_typeBindings.DQ_FormatConsistency_PropertyType = DQ_FormatConsistency_PropertyType
_Namespace_gmd.addCategoryObject('typeBinding', 'DQ_FormatConsistency_PropertyType', DQ_FormatConsistency_PropertyType)


# Complex type {http://www.isotc211.org/2005/gmd}DQ_DomainConsistency_PropertyType with content type ELEMENT_ONLY
class DQ_DomainConsistency_PropertyType (pyxb.binding.basis.complexTypeDefinition):
    """Complex type {http://www.isotc211.org/2005/gmd}DQ_DomainConsistency_PropertyType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'DQ_DomainConsistency_PropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 339, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.isotc211.org/2005/gmd}DQ_DomainConsistency uses Python identifier DQ_DomainConsistency
    __DQ_DomainConsistency = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'DQ_DomainConsistency'), 'DQ_DomainConsistency', '__httpwww_isotc211_org2005gmd_DQ_DomainConsistency_PropertyType_httpwww_isotc211_org2005gmdDQ_DomainConsistency', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 337, 1), )

    
    DQ_DomainConsistency = property(__DQ_DomainConsistency.value, __DQ_DomainConsistency.set, None, None)

    
    # Attribute uuidref uses Python identifier uuidref
    __uuidref = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'uuidref'), 'uuidref', '__httpwww_isotc211_org2005gmd_DQ_DomainConsistency_PropertyType_uuidref', pyxb.binding.datatypes.string)
    __uuidref._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 30, 2)
    __uuidref._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 30, 2)
    
    uuidref = property(__uuidref.value, __uuidref.set, None, None)

    
    # Attribute {http://www.isotc211.org/2005/gco}nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gco, 'nilReason'), 'nilReason', '__httpwww_isotc211_org2005gmd_DQ_DomainConsistency_PropertyType_httpwww_isotc211_org2005gconilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 33, 1)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 344, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}type uses Python identifier type
    __type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'type'), 'type', '__httpwww_isotc211_org2005gmd_DQ_DomainConsistency_PropertyType_httpwww_w3_org1999xlinktype', _ImportedBinding_bindings_v1411_write__xlink.typeType, fixed=True, unicode_default='simple')
    __type._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 29, 1)
    __type._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 112, 2)
    
    type = property(__type.value, __type.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}href uses Python identifier href
    __href = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'href'), 'href', '__httpwww_isotc211_org2005gmd_DQ_DomainConsistency_PropertyType_httpwww_w3_org1999xlinkhref', _ImportedBinding_bindings_v1411_write__xlink.hrefType)
    __href._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 42, 1)
    __href._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 113, 2)
    
    href = property(__href.value, __href.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}role uses Python identifier role
    __role = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'role'), 'role', '__httpwww_isotc211_org2005gmd_DQ_DomainConsistency_PropertyType_httpwww_w3_org1999xlinkrole', _ImportedBinding_bindings_v1411_write__xlink.roleType)
    __role._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 48, 1)
    __role._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 114, 2)
    
    role = property(__role.value, __role.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}arcrole uses Python identifier arcrole
    __arcrole = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'arcrole'), 'arcrole', '__httpwww_isotc211_org2005gmd_DQ_DomainConsistency_PropertyType_httpwww_w3_org1999xlinkarcrole', _ImportedBinding_bindings_v1411_write__xlink.arcroleType)
    __arcrole._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 56, 1)
    __arcrole._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 115, 2)
    
    arcrole = property(__arcrole.value, __arcrole.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}title uses Python identifier title
    __title = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'title'), 'title', '__httpwww_isotc211_org2005gmd_DQ_DomainConsistency_PropertyType_httpwww_w3_org1999xlinktitle', _ImportedBinding_bindings_v1411_write__xlink.titleAttrType)
    __title._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 64, 1)
    __title._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 116, 2)
    
    title = property(__title.value, __title.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}show uses Python identifier show
    __show = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'show'), 'show', '__httpwww_isotc211_org2005gmd_DQ_DomainConsistency_PropertyType_httpwww_w3_org1999xlinkshow', _ImportedBinding_bindings_v1411_write__xlink.showType)
    __show._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 70, 1)
    __show._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 117, 2)
    
    show = property(__show.value, __show.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}actuate uses Python identifier actuate
    __actuate = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'actuate'), 'actuate', '__httpwww_isotc211_org2005gmd_DQ_DomainConsistency_PropertyType_httpwww_w3_org1999xlinkactuate', _ImportedBinding_bindings_v1411_write__xlink.actuateType)
    __actuate._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 82, 1)
    __actuate._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 118, 2)
    
    actuate = property(__actuate.value, __actuate.set, None, None)

    _ElementMap.update({
        __DQ_DomainConsistency.name() : __DQ_DomainConsistency
    })
    _AttributeMap.update({
        __uuidref.name() : __uuidref,
        __nilReason.name() : __nilReason,
        __type.name() : __type,
        __href.name() : __href,
        __role.name() : __role,
        __arcrole.name() : __arcrole,
        __title.name() : __title,
        __show.name() : __show,
        __actuate.name() : __actuate
    })
_module_typeBindings.DQ_DomainConsistency_PropertyType = DQ_DomainConsistency_PropertyType
_Namespace_gmd.addCategoryObject('typeBinding', 'DQ_DomainConsistency_PropertyType', DQ_DomainConsistency_PropertyType)


# Complex type {http://www.isotc211.org/2005/gmd}DQ_ConceptualConsistency_PropertyType with content type ELEMENT_ONLY
class DQ_ConceptualConsistency_PropertyType (pyxb.binding.basis.complexTypeDefinition):
    """Complex type {http://www.isotc211.org/2005/gmd}DQ_ConceptualConsistency_PropertyType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'DQ_ConceptualConsistency_PropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 355, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.isotc211.org/2005/gmd}DQ_ConceptualConsistency uses Python identifier DQ_ConceptualConsistency
    __DQ_ConceptualConsistency = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'DQ_ConceptualConsistency'), 'DQ_ConceptualConsistency', '__httpwww_isotc211_org2005gmd_DQ_ConceptualConsistency_PropertyType_httpwww_isotc211_org2005gmdDQ_ConceptualConsistency', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 353, 1), )

    
    DQ_ConceptualConsistency = property(__DQ_ConceptualConsistency.value, __DQ_ConceptualConsistency.set, None, None)

    
    # Attribute uuidref uses Python identifier uuidref
    __uuidref = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'uuidref'), 'uuidref', '__httpwww_isotc211_org2005gmd_DQ_ConceptualConsistency_PropertyType_uuidref', pyxb.binding.datatypes.string)
    __uuidref._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 30, 2)
    __uuidref._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 30, 2)
    
    uuidref = property(__uuidref.value, __uuidref.set, None, None)

    
    # Attribute {http://www.isotc211.org/2005/gco}nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gco, 'nilReason'), 'nilReason', '__httpwww_isotc211_org2005gmd_DQ_ConceptualConsistency_PropertyType_httpwww_isotc211_org2005gconilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 33, 1)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 360, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}type uses Python identifier type
    __type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'type'), 'type', '__httpwww_isotc211_org2005gmd_DQ_ConceptualConsistency_PropertyType_httpwww_w3_org1999xlinktype', _ImportedBinding_bindings_v1411_write__xlink.typeType, fixed=True, unicode_default='simple')
    __type._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 29, 1)
    __type._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 112, 2)
    
    type = property(__type.value, __type.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}href uses Python identifier href
    __href = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'href'), 'href', '__httpwww_isotc211_org2005gmd_DQ_ConceptualConsistency_PropertyType_httpwww_w3_org1999xlinkhref', _ImportedBinding_bindings_v1411_write__xlink.hrefType)
    __href._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 42, 1)
    __href._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 113, 2)
    
    href = property(__href.value, __href.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}role uses Python identifier role
    __role = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'role'), 'role', '__httpwww_isotc211_org2005gmd_DQ_ConceptualConsistency_PropertyType_httpwww_w3_org1999xlinkrole', _ImportedBinding_bindings_v1411_write__xlink.roleType)
    __role._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 48, 1)
    __role._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 114, 2)
    
    role = property(__role.value, __role.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}arcrole uses Python identifier arcrole
    __arcrole = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'arcrole'), 'arcrole', '__httpwww_isotc211_org2005gmd_DQ_ConceptualConsistency_PropertyType_httpwww_w3_org1999xlinkarcrole', _ImportedBinding_bindings_v1411_write__xlink.arcroleType)
    __arcrole._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 56, 1)
    __arcrole._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 115, 2)
    
    arcrole = property(__arcrole.value, __arcrole.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}title uses Python identifier title
    __title = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'title'), 'title', '__httpwww_isotc211_org2005gmd_DQ_ConceptualConsistency_PropertyType_httpwww_w3_org1999xlinktitle', _ImportedBinding_bindings_v1411_write__xlink.titleAttrType)
    __title._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 64, 1)
    __title._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 116, 2)
    
    title = property(__title.value, __title.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}show uses Python identifier show
    __show = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'show'), 'show', '__httpwww_isotc211_org2005gmd_DQ_ConceptualConsistency_PropertyType_httpwww_w3_org1999xlinkshow', _ImportedBinding_bindings_v1411_write__xlink.showType)
    __show._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 70, 1)
    __show._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 117, 2)
    
    show = property(__show.value, __show.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}actuate uses Python identifier actuate
    __actuate = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'actuate'), 'actuate', '__httpwww_isotc211_org2005gmd_DQ_ConceptualConsistency_PropertyType_httpwww_w3_org1999xlinkactuate', _ImportedBinding_bindings_v1411_write__xlink.actuateType)
    __actuate._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 82, 1)
    __actuate._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 118, 2)
    
    actuate = property(__actuate.value, __actuate.set, None, None)

    _ElementMap.update({
        __DQ_ConceptualConsistency.name() : __DQ_ConceptualConsistency
    })
    _AttributeMap.update({
        __uuidref.name() : __uuidref,
        __nilReason.name() : __nilReason,
        __type.name() : __type,
        __href.name() : __href,
        __role.name() : __role,
        __arcrole.name() : __arcrole,
        __title.name() : __title,
        __show.name() : __show,
        __actuate.name() : __actuate
    })
_module_typeBindings.DQ_ConceptualConsistency_PropertyType = DQ_ConceptualConsistency_PropertyType
_Namespace_gmd.addCategoryObject('typeBinding', 'DQ_ConceptualConsistency_PropertyType', DQ_ConceptualConsistency_PropertyType)


# Complex type {http://www.isotc211.org/2005/gmd}DQ_CompletenessOmission_PropertyType with content type ELEMENT_ONLY
class DQ_CompletenessOmission_PropertyType (pyxb.binding.basis.complexTypeDefinition):
    """Complex type {http://www.isotc211.org/2005/gmd}DQ_CompletenessOmission_PropertyType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'DQ_CompletenessOmission_PropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 371, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.isotc211.org/2005/gmd}DQ_CompletenessOmission uses Python identifier DQ_CompletenessOmission
    __DQ_CompletenessOmission = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'DQ_CompletenessOmission'), 'DQ_CompletenessOmission', '__httpwww_isotc211_org2005gmd_DQ_CompletenessOmission_PropertyType_httpwww_isotc211_org2005gmdDQ_CompletenessOmission', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 369, 1), )

    
    DQ_CompletenessOmission = property(__DQ_CompletenessOmission.value, __DQ_CompletenessOmission.set, None, None)

    
    # Attribute uuidref uses Python identifier uuidref
    __uuidref = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'uuidref'), 'uuidref', '__httpwww_isotc211_org2005gmd_DQ_CompletenessOmission_PropertyType_uuidref', pyxb.binding.datatypes.string)
    __uuidref._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 30, 2)
    __uuidref._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 30, 2)
    
    uuidref = property(__uuidref.value, __uuidref.set, None, None)

    
    # Attribute {http://www.isotc211.org/2005/gco}nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gco, 'nilReason'), 'nilReason', '__httpwww_isotc211_org2005gmd_DQ_CompletenessOmission_PropertyType_httpwww_isotc211_org2005gconilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 33, 1)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 376, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}type uses Python identifier type
    __type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'type'), 'type', '__httpwww_isotc211_org2005gmd_DQ_CompletenessOmission_PropertyType_httpwww_w3_org1999xlinktype', _ImportedBinding_bindings_v1411_write__xlink.typeType, fixed=True, unicode_default='simple')
    __type._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 29, 1)
    __type._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 112, 2)
    
    type = property(__type.value, __type.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}href uses Python identifier href
    __href = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'href'), 'href', '__httpwww_isotc211_org2005gmd_DQ_CompletenessOmission_PropertyType_httpwww_w3_org1999xlinkhref', _ImportedBinding_bindings_v1411_write__xlink.hrefType)
    __href._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 42, 1)
    __href._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 113, 2)
    
    href = property(__href.value, __href.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}role uses Python identifier role
    __role = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'role'), 'role', '__httpwww_isotc211_org2005gmd_DQ_CompletenessOmission_PropertyType_httpwww_w3_org1999xlinkrole', _ImportedBinding_bindings_v1411_write__xlink.roleType)
    __role._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 48, 1)
    __role._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 114, 2)
    
    role = property(__role.value, __role.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}arcrole uses Python identifier arcrole
    __arcrole = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'arcrole'), 'arcrole', '__httpwww_isotc211_org2005gmd_DQ_CompletenessOmission_PropertyType_httpwww_w3_org1999xlinkarcrole', _ImportedBinding_bindings_v1411_write__xlink.arcroleType)
    __arcrole._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 56, 1)
    __arcrole._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 115, 2)
    
    arcrole = property(__arcrole.value, __arcrole.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}title uses Python identifier title
    __title = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'title'), 'title', '__httpwww_isotc211_org2005gmd_DQ_CompletenessOmission_PropertyType_httpwww_w3_org1999xlinktitle', _ImportedBinding_bindings_v1411_write__xlink.titleAttrType)
    __title._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 64, 1)
    __title._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 116, 2)
    
    title = property(__title.value, __title.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}show uses Python identifier show
    __show = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'show'), 'show', '__httpwww_isotc211_org2005gmd_DQ_CompletenessOmission_PropertyType_httpwww_w3_org1999xlinkshow', _ImportedBinding_bindings_v1411_write__xlink.showType)
    __show._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 70, 1)
    __show._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 117, 2)
    
    show = property(__show.value, __show.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}actuate uses Python identifier actuate
    __actuate = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'actuate'), 'actuate', '__httpwww_isotc211_org2005gmd_DQ_CompletenessOmission_PropertyType_httpwww_w3_org1999xlinkactuate', _ImportedBinding_bindings_v1411_write__xlink.actuateType)
    __actuate._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 82, 1)
    __actuate._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 118, 2)
    
    actuate = property(__actuate.value, __actuate.set, None, None)

    _ElementMap.update({
        __DQ_CompletenessOmission.name() : __DQ_CompletenessOmission
    })
    _AttributeMap.update({
        __uuidref.name() : __uuidref,
        __nilReason.name() : __nilReason,
        __type.name() : __type,
        __href.name() : __href,
        __role.name() : __role,
        __arcrole.name() : __arcrole,
        __title.name() : __title,
        __show.name() : __show,
        __actuate.name() : __actuate
    })
_module_typeBindings.DQ_CompletenessOmission_PropertyType = DQ_CompletenessOmission_PropertyType
_Namespace_gmd.addCategoryObject('typeBinding', 'DQ_CompletenessOmission_PropertyType', DQ_CompletenessOmission_PropertyType)


# Complex type {http://www.isotc211.org/2005/gmd}DQ_CompletenessCommission_PropertyType with content type ELEMENT_ONLY
class DQ_CompletenessCommission_PropertyType (pyxb.binding.basis.complexTypeDefinition):
    """Complex type {http://www.isotc211.org/2005/gmd}DQ_CompletenessCommission_PropertyType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'DQ_CompletenessCommission_PropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 387, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.isotc211.org/2005/gmd}DQ_CompletenessCommission uses Python identifier DQ_CompletenessCommission
    __DQ_CompletenessCommission = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'DQ_CompletenessCommission'), 'DQ_CompletenessCommission', '__httpwww_isotc211_org2005gmd_DQ_CompletenessCommission_PropertyType_httpwww_isotc211_org2005gmdDQ_CompletenessCommission', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 385, 1), )

    
    DQ_CompletenessCommission = property(__DQ_CompletenessCommission.value, __DQ_CompletenessCommission.set, None, None)

    
    # Attribute uuidref uses Python identifier uuidref
    __uuidref = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'uuidref'), 'uuidref', '__httpwww_isotc211_org2005gmd_DQ_CompletenessCommission_PropertyType_uuidref', pyxb.binding.datatypes.string)
    __uuidref._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 30, 2)
    __uuidref._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 30, 2)
    
    uuidref = property(__uuidref.value, __uuidref.set, None, None)

    
    # Attribute {http://www.isotc211.org/2005/gco}nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gco, 'nilReason'), 'nilReason', '__httpwww_isotc211_org2005gmd_DQ_CompletenessCommission_PropertyType_httpwww_isotc211_org2005gconilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 33, 1)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 392, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}type uses Python identifier type
    __type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'type'), 'type', '__httpwww_isotc211_org2005gmd_DQ_CompletenessCommission_PropertyType_httpwww_w3_org1999xlinktype', _ImportedBinding_bindings_v1411_write__xlink.typeType, fixed=True, unicode_default='simple')
    __type._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 29, 1)
    __type._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 112, 2)
    
    type = property(__type.value, __type.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}href uses Python identifier href
    __href = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'href'), 'href', '__httpwww_isotc211_org2005gmd_DQ_CompletenessCommission_PropertyType_httpwww_w3_org1999xlinkhref', _ImportedBinding_bindings_v1411_write__xlink.hrefType)
    __href._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 42, 1)
    __href._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 113, 2)
    
    href = property(__href.value, __href.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}role uses Python identifier role
    __role = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'role'), 'role', '__httpwww_isotc211_org2005gmd_DQ_CompletenessCommission_PropertyType_httpwww_w3_org1999xlinkrole', _ImportedBinding_bindings_v1411_write__xlink.roleType)
    __role._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 48, 1)
    __role._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 114, 2)
    
    role = property(__role.value, __role.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}arcrole uses Python identifier arcrole
    __arcrole = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'arcrole'), 'arcrole', '__httpwww_isotc211_org2005gmd_DQ_CompletenessCommission_PropertyType_httpwww_w3_org1999xlinkarcrole', _ImportedBinding_bindings_v1411_write__xlink.arcroleType)
    __arcrole._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 56, 1)
    __arcrole._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 115, 2)
    
    arcrole = property(__arcrole.value, __arcrole.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}title uses Python identifier title
    __title = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'title'), 'title', '__httpwww_isotc211_org2005gmd_DQ_CompletenessCommission_PropertyType_httpwww_w3_org1999xlinktitle', _ImportedBinding_bindings_v1411_write__xlink.titleAttrType)
    __title._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 64, 1)
    __title._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 116, 2)
    
    title = property(__title.value, __title.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}show uses Python identifier show
    __show = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'show'), 'show', '__httpwww_isotc211_org2005gmd_DQ_CompletenessCommission_PropertyType_httpwww_w3_org1999xlinkshow', _ImportedBinding_bindings_v1411_write__xlink.showType)
    __show._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 70, 1)
    __show._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 117, 2)
    
    show = property(__show.value, __show.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}actuate uses Python identifier actuate
    __actuate = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'actuate'), 'actuate', '__httpwww_isotc211_org2005gmd_DQ_CompletenessCommission_PropertyType_httpwww_w3_org1999xlinkactuate', _ImportedBinding_bindings_v1411_write__xlink.actuateType)
    __actuate._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 82, 1)
    __actuate._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 118, 2)
    
    actuate = property(__actuate.value, __actuate.set, None, None)

    _ElementMap.update({
        __DQ_CompletenessCommission.name() : __DQ_CompletenessCommission
    })
    _AttributeMap.update({
        __uuidref.name() : __uuidref,
        __nilReason.name() : __nilReason,
        __type.name() : __type,
        __href.name() : __href,
        __role.name() : __role,
        __arcrole.name() : __arcrole,
        __title.name() : __title,
        __show.name() : __show,
        __actuate.name() : __actuate
    })
_module_typeBindings.DQ_CompletenessCommission_PropertyType = DQ_CompletenessCommission_PropertyType
_Namespace_gmd.addCategoryObject('typeBinding', 'DQ_CompletenessCommission_PropertyType', DQ_CompletenessCommission_PropertyType)


# Complex type {http://www.isotc211.org/2005/gmd}AbstractDQ_TemporalAccuracy_Type with content type ELEMENT_ONLY
class AbstractDQ_TemporalAccuracy_Type (AbstractDQ_Element_Type):
    """Complex type {http://www.isotc211.org/2005/gmd}AbstractDQ_TemporalAccuracy_Type with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = True
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'AbstractDQ_TemporalAccuracy_Type')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 395, 1)
    _ElementMap = AbstractDQ_Element_Type._ElementMap.copy()
    _AttributeMap = AbstractDQ_Element_Type._AttributeMap.copy()
    # Base type is AbstractDQ_Element_Type
    
    # Element nameOfMeasure ({http://www.isotc211.org/2005/gmd}nameOfMeasure) inherited from {http://www.isotc211.org/2005/gmd}AbstractDQ_Element_Type
    
    # Element measureIdentification ({http://www.isotc211.org/2005/gmd}measureIdentification) inherited from {http://www.isotc211.org/2005/gmd}AbstractDQ_Element_Type
    
    # Element measureDescription ({http://www.isotc211.org/2005/gmd}measureDescription) inherited from {http://www.isotc211.org/2005/gmd}AbstractDQ_Element_Type
    
    # Element evaluationMethodType ({http://www.isotc211.org/2005/gmd}evaluationMethodType) inherited from {http://www.isotc211.org/2005/gmd}AbstractDQ_Element_Type
    
    # Element evaluationMethodDescription ({http://www.isotc211.org/2005/gmd}evaluationMethodDescription) inherited from {http://www.isotc211.org/2005/gmd}AbstractDQ_Element_Type
    
    # Element evaluationProcedure ({http://www.isotc211.org/2005/gmd}evaluationProcedure) inherited from {http://www.isotc211.org/2005/gmd}AbstractDQ_Element_Type
    
    # Element dateTime ({http://www.isotc211.org/2005/gmd}dateTime) inherited from {http://www.isotc211.org/2005/gmd}AbstractDQ_Element_Type
    
    # Element result ({http://www.isotc211.org/2005/gmd}result) inherited from {http://www.isotc211.org/2005/gmd}AbstractDQ_Element_Type
    
    # Attribute id inherited from {http://www.isotc211.org/2005/gco}AbstractObject_Type
    
    # Attribute uuid inherited from {http://www.isotc211.org/2005/gco}AbstractObject_Type
    _ElementMap.update({
        
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.AbstractDQ_TemporalAccuracy_Type = AbstractDQ_TemporalAccuracy_Type
_Namespace_gmd.addCategoryObject('typeBinding', 'AbstractDQ_TemporalAccuracy_Type', AbstractDQ_TemporalAccuracy_Type)


# Complex type {http://www.isotc211.org/2005/gmd}DQ_TemporalAccuracy_PropertyType with content type ELEMENT_ONLY
class DQ_TemporalAccuracy_PropertyType (pyxb.binding.basis.complexTypeDefinition):
    """Complex type {http://www.isotc211.org/2005/gmd}DQ_TemporalAccuracy_PropertyType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'DQ_TemporalAccuracy_PropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 403, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.isotc211.org/2005/gmd}AbstractDQ_TemporalAccuracy uses Python identifier AbstractDQ_TemporalAccuracy
    __AbstractDQ_TemporalAccuracy = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'AbstractDQ_TemporalAccuracy'), 'AbstractDQ_TemporalAccuracy', '__httpwww_isotc211_org2005gmd_DQ_TemporalAccuracy_PropertyType_httpwww_isotc211_org2005gmdAbstractDQ_TemporalAccuracy', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 401, 1), )

    
    AbstractDQ_TemporalAccuracy = property(__AbstractDQ_TemporalAccuracy.value, __AbstractDQ_TemporalAccuracy.set, None, None)

    
    # Attribute uuidref uses Python identifier uuidref
    __uuidref = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'uuidref'), 'uuidref', '__httpwww_isotc211_org2005gmd_DQ_TemporalAccuracy_PropertyType_uuidref', pyxb.binding.datatypes.string)
    __uuidref._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 30, 2)
    __uuidref._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 30, 2)
    
    uuidref = property(__uuidref.value, __uuidref.set, None, None)

    
    # Attribute {http://www.isotc211.org/2005/gco}nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gco, 'nilReason'), 'nilReason', '__httpwww_isotc211_org2005gmd_DQ_TemporalAccuracy_PropertyType_httpwww_isotc211_org2005gconilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 33, 1)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 408, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}type uses Python identifier type
    __type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'type'), 'type', '__httpwww_isotc211_org2005gmd_DQ_TemporalAccuracy_PropertyType_httpwww_w3_org1999xlinktype', _ImportedBinding_bindings_v1411_write__xlink.typeType, fixed=True, unicode_default='simple')
    __type._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 29, 1)
    __type._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 112, 2)
    
    type = property(__type.value, __type.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}href uses Python identifier href
    __href = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'href'), 'href', '__httpwww_isotc211_org2005gmd_DQ_TemporalAccuracy_PropertyType_httpwww_w3_org1999xlinkhref', _ImportedBinding_bindings_v1411_write__xlink.hrefType)
    __href._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 42, 1)
    __href._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 113, 2)
    
    href = property(__href.value, __href.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}role uses Python identifier role
    __role = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'role'), 'role', '__httpwww_isotc211_org2005gmd_DQ_TemporalAccuracy_PropertyType_httpwww_w3_org1999xlinkrole', _ImportedBinding_bindings_v1411_write__xlink.roleType)
    __role._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 48, 1)
    __role._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 114, 2)
    
    role = property(__role.value, __role.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}arcrole uses Python identifier arcrole
    __arcrole = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'arcrole'), 'arcrole', '__httpwww_isotc211_org2005gmd_DQ_TemporalAccuracy_PropertyType_httpwww_w3_org1999xlinkarcrole', _ImportedBinding_bindings_v1411_write__xlink.arcroleType)
    __arcrole._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 56, 1)
    __arcrole._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 115, 2)
    
    arcrole = property(__arcrole.value, __arcrole.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}title uses Python identifier title
    __title = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'title'), 'title', '__httpwww_isotc211_org2005gmd_DQ_TemporalAccuracy_PropertyType_httpwww_w3_org1999xlinktitle', _ImportedBinding_bindings_v1411_write__xlink.titleAttrType)
    __title._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 64, 1)
    __title._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 116, 2)
    
    title = property(__title.value, __title.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}show uses Python identifier show
    __show = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'show'), 'show', '__httpwww_isotc211_org2005gmd_DQ_TemporalAccuracy_PropertyType_httpwww_w3_org1999xlinkshow', _ImportedBinding_bindings_v1411_write__xlink.showType)
    __show._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 70, 1)
    __show._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 117, 2)
    
    show = property(__show.value, __show.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}actuate uses Python identifier actuate
    __actuate = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'actuate'), 'actuate', '__httpwww_isotc211_org2005gmd_DQ_TemporalAccuracy_PropertyType_httpwww_w3_org1999xlinkactuate', _ImportedBinding_bindings_v1411_write__xlink.actuateType)
    __actuate._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 82, 1)
    __actuate._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 118, 2)
    
    actuate = property(__actuate.value, __actuate.set, None, None)

    _ElementMap.update({
        __AbstractDQ_TemporalAccuracy.name() : __AbstractDQ_TemporalAccuracy
    })
    _AttributeMap.update({
        __uuidref.name() : __uuidref,
        __nilReason.name() : __nilReason,
        __type.name() : __type,
        __href.name() : __href,
        __role.name() : __role,
        __arcrole.name() : __arcrole,
        __title.name() : __title,
        __show.name() : __show,
        __actuate.name() : __actuate
    })
_module_typeBindings.DQ_TemporalAccuracy_PropertyType = DQ_TemporalAccuracy_PropertyType
_Namespace_gmd.addCategoryObject('typeBinding', 'DQ_TemporalAccuracy_PropertyType', DQ_TemporalAccuracy_PropertyType)


# Complex type {http://www.isotc211.org/2005/gmd}AbstractDQ_ThematicAccuracy_Type with content type ELEMENT_ONLY
class AbstractDQ_ThematicAccuracy_Type (AbstractDQ_Element_Type):
    """Complex type {http://www.isotc211.org/2005/gmd}AbstractDQ_ThematicAccuracy_Type with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = True
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'AbstractDQ_ThematicAccuracy_Type')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 411, 1)
    _ElementMap = AbstractDQ_Element_Type._ElementMap.copy()
    _AttributeMap = AbstractDQ_Element_Type._AttributeMap.copy()
    # Base type is AbstractDQ_Element_Type
    
    # Element nameOfMeasure ({http://www.isotc211.org/2005/gmd}nameOfMeasure) inherited from {http://www.isotc211.org/2005/gmd}AbstractDQ_Element_Type
    
    # Element measureIdentification ({http://www.isotc211.org/2005/gmd}measureIdentification) inherited from {http://www.isotc211.org/2005/gmd}AbstractDQ_Element_Type
    
    # Element measureDescription ({http://www.isotc211.org/2005/gmd}measureDescription) inherited from {http://www.isotc211.org/2005/gmd}AbstractDQ_Element_Type
    
    # Element evaluationMethodType ({http://www.isotc211.org/2005/gmd}evaluationMethodType) inherited from {http://www.isotc211.org/2005/gmd}AbstractDQ_Element_Type
    
    # Element evaluationMethodDescription ({http://www.isotc211.org/2005/gmd}evaluationMethodDescription) inherited from {http://www.isotc211.org/2005/gmd}AbstractDQ_Element_Type
    
    # Element evaluationProcedure ({http://www.isotc211.org/2005/gmd}evaluationProcedure) inherited from {http://www.isotc211.org/2005/gmd}AbstractDQ_Element_Type
    
    # Element dateTime ({http://www.isotc211.org/2005/gmd}dateTime) inherited from {http://www.isotc211.org/2005/gmd}AbstractDQ_Element_Type
    
    # Element result ({http://www.isotc211.org/2005/gmd}result) inherited from {http://www.isotc211.org/2005/gmd}AbstractDQ_Element_Type
    
    # Attribute id inherited from {http://www.isotc211.org/2005/gco}AbstractObject_Type
    
    # Attribute uuid inherited from {http://www.isotc211.org/2005/gco}AbstractObject_Type
    _ElementMap.update({
        
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.AbstractDQ_ThematicAccuracy_Type = AbstractDQ_ThematicAccuracy_Type
_Namespace_gmd.addCategoryObject('typeBinding', 'AbstractDQ_ThematicAccuracy_Type', AbstractDQ_ThematicAccuracy_Type)


# Complex type {http://www.isotc211.org/2005/gmd}DQ_ThematicAccuracy_PropertyType with content type ELEMENT_ONLY
class DQ_ThematicAccuracy_PropertyType (pyxb.binding.basis.complexTypeDefinition):
    """Complex type {http://www.isotc211.org/2005/gmd}DQ_ThematicAccuracy_PropertyType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'DQ_ThematicAccuracy_PropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 419, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.isotc211.org/2005/gmd}AbstractDQ_ThematicAccuracy uses Python identifier AbstractDQ_ThematicAccuracy
    __AbstractDQ_ThematicAccuracy = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'AbstractDQ_ThematicAccuracy'), 'AbstractDQ_ThematicAccuracy', '__httpwww_isotc211_org2005gmd_DQ_ThematicAccuracy_PropertyType_httpwww_isotc211_org2005gmdAbstractDQ_ThematicAccuracy', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 417, 1), )

    
    AbstractDQ_ThematicAccuracy = property(__AbstractDQ_ThematicAccuracy.value, __AbstractDQ_ThematicAccuracy.set, None, None)

    
    # Attribute uuidref uses Python identifier uuidref
    __uuidref = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'uuidref'), 'uuidref', '__httpwww_isotc211_org2005gmd_DQ_ThematicAccuracy_PropertyType_uuidref', pyxb.binding.datatypes.string)
    __uuidref._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 30, 2)
    __uuidref._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 30, 2)
    
    uuidref = property(__uuidref.value, __uuidref.set, None, None)

    
    # Attribute {http://www.isotc211.org/2005/gco}nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gco, 'nilReason'), 'nilReason', '__httpwww_isotc211_org2005gmd_DQ_ThematicAccuracy_PropertyType_httpwww_isotc211_org2005gconilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 33, 1)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 424, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}type uses Python identifier type
    __type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'type'), 'type', '__httpwww_isotc211_org2005gmd_DQ_ThematicAccuracy_PropertyType_httpwww_w3_org1999xlinktype', _ImportedBinding_bindings_v1411_write__xlink.typeType, fixed=True, unicode_default='simple')
    __type._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 29, 1)
    __type._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 112, 2)
    
    type = property(__type.value, __type.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}href uses Python identifier href
    __href = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'href'), 'href', '__httpwww_isotc211_org2005gmd_DQ_ThematicAccuracy_PropertyType_httpwww_w3_org1999xlinkhref', _ImportedBinding_bindings_v1411_write__xlink.hrefType)
    __href._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 42, 1)
    __href._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 113, 2)
    
    href = property(__href.value, __href.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}role uses Python identifier role
    __role = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'role'), 'role', '__httpwww_isotc211_org2005gmd_DQ_ThematicAccuracy_PropertyType_httpwww_w3_org1999xlinkrole', _ImportedBinding_bindings_v1411_write__xlink.roleType)
    __role._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 48, 1)
    __role._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 114, 2)
    
    role = property(__role.value, __role.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}arcrole uses Python identifier arcrole
    __arcrole = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'arcrole'), 'arcrole', '__httpwww_isotc211_org2005gmd_DQ_ThematicAccuracy_PropertyType_httpwww_w3_org1999xlinkarcrole', _ImportedBinding_bindings_v1411_write__xlink.arcroleType)
    __arcrole._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 56, 1)
    __arcrole._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 115, 2)
    
    arcrole = property(__arcrole.value, __arcrole.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}title uses Python identifier title
    __title = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'title'), 'title', '__httpwww_isotc211_org2005gmd_DQ_ThematicAccuracy_PropertyType_httpwww_w3_org1999xlinktitle', _ImportedBinding_bindings_v1411_write__xlink.titleAttrType)
    __title._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 64, 1)
    __title._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 116, 2)
    
    title = property(__title.value, __title.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}show uses Python identifier show
    __show = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'show'), 'show', '__httpwww_isotc211_org2005gmd_DQ_ThematicAccuracy_PropertyType_httpwww_w3_org1999xlinkshow', _ImportedBinding_bindings_v1411_write__xlink.showType)
    __show._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 70, 1)
    __show._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 117, 2)
    
    show = property(__show.value, __show.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}actuate uses Python identifier actuate
    __actuate = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'actuate'), 'actuate', '__httpwww_isotc211_org2005gmd_DQ_ThematicAccuracy_PropertyType_httpwww_w3_org1999xlinkactuate', _ImportedBinding_bindings_v1411_write__xlink.actuateType)
    __actuate._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 82, 1)
    __actuate._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 118, 2)
    
    actuate = property(__actuate.value, __actuate.set, None, None)

    _ElementMap.update({
        __AbstractDQ_ThematicAccuracy.name() : __AbstractDQ_ThematicAccuracy
    })
    _AttributeMap.update({
        __uuidref.name() : __uuidref,
        __nilReason.name() : __nilReason,
        __type.name() : __type,
        __href.name() : __href,
        __role.name() : __role,
        __arcrole.name() : __arcrole,
        __title.name() : __title,
        __show.name() : __show,
        __actuate.name() : __actuate
    })
_module_typeBindings.DQ_ThematicAccuracy_PropertyType = DQ_ThematicAccuracy_PropertyType
_Namespace_gmd.addCategoryObject('typeBinding', 'DQ_ThematicAccuracy_PropertyType', DQ_ThematicAccuracy_PropertyType)


# Complex type {http://www.isotc211.org/2005/gmd}AbstractDQ_PositionalAccuracy_Type with content type ELEMENT_ONLY
class AbstractDQ_PositionalAccuracy_Type (AbstractDQ_Element_Type):
    """Complex type {http://www.isotc211.org/2005/gmd}AbstractDQ_PositionalAccuracy_Type with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = True
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'AbstractDQ_PositionalAccuracy_Type')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 427, 1)
    _ElementMap = AbstractDQ_Element_Type._ElementMap.copy()
    _AttributeMap = AbstractDQ_Element_Type._AttributeMap.copy()
    # Base type is AbstractDQ_Element_Type
    
    # Element nameOfMeasure ({http://www.isotc211.org/2005/gmd}nameOfMeasure) inherited from {http://www.isotc211.org/2005/gmd}AbstractDQ_Element_Type
    
    # Element measureIdentification ({http://www.isotc211.org/2005/gmd}measureIdentification) inherited from {http://www.isotc211.org/2005/gmd}AbstractDQ_Element_Type
    
    # Element measureDescription ({http://www.isotc211.org/2005/gmd}measureDescription) inherited from {http://www.isotc211.org/2005/gmd}AbstractDQ_Element_Type
    
    # Element evaluationMethodType ({http://www.isotc211.org/2005/gmd}evaluationMethodType) inherited from {http://www.isotc211.org/2005/gmd}AbstractDQ_Element_Type
    
    # Element evaluationMethodDescription ({http://www.isotc211.org/2005/gmd}evaluationMethodDescription) inherited from {http://www.isotc211.org/2005/gmd}AbstractDQ_Element_Type
    
    # Element evaluationProcedure ({http://www.isotc211.org/2005/gmd}evaluationProcedure) inherited from {http://www.isotc211.org/2005/gmd}AbstractDQ_Element_Type
    
    # Element dateTime ({http://www.isotc211.org/2005/gmd}dateTime) inherited from {http://www.isotc211.org/2005/gmd}AbstractDQ_Element_Type
    
    # Element result ({http://www.isotc211.org/2005/gmd}result) inherited from {http://www.isotc211.org/2005/gmd}AbstractDQ_Element_Type
    
    # Attribute id inherited from {http://www.isotc211.org/2005/gco}AbstractObject_Type
    
    # Attribute uuid inherited from {http://www.isotc211.org/2005/gco}AbstractObject_Type
    _ElementMap.update({
        
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.AbstractDQ_PositionalAccuracy_Type = AbstractDQ_PositionalAccuracy_Type
_Namespace_gmd.addCategoryObject('typeBinding', 'AbstractDQ_PositionalAccuracy_Type', AbstractDQ_PositionalAccuracy_Type)


# Complex type {http://www.isotc211.org/2005/gmd}DQ_PositionalAccuracy_PropertyType with content type ELEMENT_ONLY
class DQ_PositionalAccuracy_PropertyType (pyxb.binding.basis.complexTypeDefinition):
    """Complex type {http://www.isotc211.org/2005/gmd}DQ_PositionalAccuracy_PropertyType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'DQ_PositionalAccuracy_PropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 435, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.isotc211.org/2005/gmd}AbstractDQ_PositionalAccuracy uses Python identifier AbstractDQ_PositionalAccuracy
    __AbstractDQ_PositionalAccuracy = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'AbstractDQ_PositionalAccuracy'), 'AbstractDQ_PositionalAccuracy', '__httpwww_isotc211_org2005gmd_DQ_PositionalAccuracy_PropertyType_httpwww_isotc211_org2005gmdAbstractDQ_PositionalAccuracy', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 433, 1), )

    
    AbstractDQ_PositionalAccuracy = property(__AbstractDQ_PositionalAccuracy.value, __AbstractDQ_PositionalAccuracy.set, None, None)

    
    # Attribute uuidref uses Python identifier uuidref
    __uuidref = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'uuidref'), 'uuidref', '__httpwww_isotc211_org2005gmd_DQ_PositionalAccuracy_PropertyType_uuidref', pyxb.binding.datatypes.string)
    __uuidref._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 30, 2)
    __uuidref._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 30, 2)
    
    uuidref = property(__uuidref.value, __uuidref.set, None, None)

    
    # Attribute {http://www.isotc211.org/2005/gco}nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gco, 'nilReason'), 'nilReason', '__httpwww_isotc211_org2005gmd_DQ_PositionalAccuracy_PropertyType_httpwww_isotc211_org2005gconilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 33, 1)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 440, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}type uses Python identifier type
    __type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'type'), 'type', '__httpwww_isotc211_org2005gmd_DQ_PositionalAccuracy_PropertyType_httpwww_w3_org1999xlinktype', _ImportedBinding_bindings_v1411_write__xlink.typeType, fixed=True, unicode_default='simple')
    __type._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 29, 1)
    __type._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 112, 2)
    
    type = property(__type.value, __type.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}href uses Python identifier href
    __href = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'href'), 'href', '__httpwww_isotc211_org2005gmd_DQ_PositionalAccuracy_PropertyType_httpwww_w3_org1999xlinkhref', _ImportedBinding_bindings_v1411_write__xlink.hrefType)
    __href._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 42, 1)
    __href._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 113, 2)
    
    href = property(__href.value, __href.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}role uses Python identifier role
    __role = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'role'), 'role', '__httpwww_isotc211_org2005gmd_DQ_PositionalAccuracy_PropertyType_httpwww_w3_org1999xlinkrole', _ImportedBinding_bindings_v1411_write__xlink.roleType)
    __role._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 48, 1)
    __role._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 114, 2)
    
    role = property(__role.value, __role.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}arcrole uses Python identifier arcrole
    __arcrole = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'arcrole'), 'arcrole', '__httpwww_isotc211_org2005gmd_DQ_PositionalAccuracy_PropertyType_httpwww_w3_org1999xlinkarcrole', _ImportedBinding_bindings_v1411_write__xlink.arcroleType)
    __arcrole._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 56, 1)
    __arcrole._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 115, 2)
    
    arcrole = property(__arcrole.value, __arcrole.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}title uses Python identifier title
    __title = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'title'), 'title', '__httpwww_isotc211_org2005gmd_DQ_PositionalAccuracy_PropertyType_httpwww_w3_org1999xlinktitle', _ImportedBinding_bindings_v1411_write__xlink.titleAttrType)
    __title._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 64, 1)
    __title._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 116, 2)
    
    title = property(__title.value, __title.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}show uses Python identifier show
    __show = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'show'), 'show', '__httpwww_isotc211_org2005gmd_DQ_PositionalAccuracy_PropertyType_httpwww_w3_org1999xlinkshow', _ImportedBinding_bindings_v1411_write__xlink.showType)
    __show._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 70, 1)
    __show._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 117, 2)
    
    show = property(__show.value, __show.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}actuate uses Python identifier actuate
    __actuate = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'actuate'), 'actuate', '__httpwww_isotc211_org2005gmd_DQ_PositionalAccuracy_PropertyType_httpwww_w3_org1999xlinkactuate', _ImportedBinding_bindings_v1411_write__xlink.actuateType)
    __actuate._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 82, 1)
    __actuate._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 118, 2)
    
    actuate = property(__actuate.value, __actuate.set, None, None)

    _ElementMap.update({
        __AbstractDQ_PositionalAccuracy.name() : __AbstractDQ_PositionalAccuracy
    })
    _AttributeMap.update({
        __uuidref.name() : __uuidref,
        __nilReason.name() : __nilReason,
        __type.name() : __type,
        __href.name() : __href,
        __role.name() : __role,
        __arcrole.name() : __arcrole,
        __title.name() : __title,
        __show.name() : __show,
        __actuate.name() : __actuate
    })
_module_typeBindings.DQ_PositionalAccuracy_PropertyType = DQ_PositionalAccuracy_PropertyType
_Namespace_gmd.addCategoryObject('typeBinding', 'DQ_PositionalAccuracy_PropertyType', DQ_PositionalAccuracy_PropertyType)


# Complex type {http://www.isotc211.org/2005/gmd}AbstractDQ_LogicalConsistency_Type with content type ELEMENT_ONLY
class AbstractDQ_LogicalConsistency_Type (AbstractDQ_Element_Type):
    """Complex type {http://www.isotc211.org/2005/gmd}AbstractDQ_LogicalConsistency_Type with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = True
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'AbstractDQ_LogicalConsistency_Type')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 443, 1)
    _ElementMap = AbstractDQ_Element_Type._ElementMap.copy()
    _AttributeMap = AbstractDQ_Element_Type._AttributeMap.copy()
    # Base type is AbstractDQ_Element_Type
    
    # Element nameOfMeasure ({http://www.isotc211.org/2005/gmd}nameOfMeasure) inherited from {http://www.isotc211.org/2005/gmd}AbstractDQ_Element_Type
    
    # Element measureIdentification ({http://www.isotc211.org/2005/gmd}measureIdentification) inherited from {http://www.isotc211.org/2005/gmd}AbstractDQ_Element_Type
    
    # Element measureDescription ({http://www.isotc211.org/2005/gmd}measureDescription) inherited from {http://www.isotc211.org/2005/gmd}AbstractDQ_Element_Type
    
    # Element evaluationMethodType ({http://www.isotc211.org/2005/gmd}evaluationMethodType) inherited from {http://www.isotc211.org/2005/gmd}AbstractDQ_Element_Type
    
    # Element evaluationMethodDescription ({http://www.isotc211.org/2005/gmd}evaluationMethodDescription) inherited from {http://www.isotc211.org/2005/gmd}AbstractDQ_Element_Type
    
    # Element evaluationProcedure ({http://www.isotc211.org/2005/gmd}evaluationProcedure) inherited from {http://www.isotc211.org/2005/gmd}AbstractDQ_Element_Type
    
    # Element dateTime ({http://www.isotc211.org/2005/gmd}dateTime) inherited from {http://www.isotc211.org/2005/gmd}AbstractDQ_Element_Type
    
    # Element result ({http://www.isotc211.org/2005/gmd}result) inherited from {http://www.isotc211.org/2005/gmd}AbstractDQ_Element_Type
    
    # Attribute id inherited from {http://www.isotc211.org/2005/gco}AbstractObject_Type
    
    # Attribute uuid inherited from {http://www.isotc211.org/2005/gco}AbstractObject_Type
    _ElementMap.update({
        
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.AbstractDQ_LogicalConsistency_Type = AbstractDQ_LogicalConsistency_Type
_Namespace_gmd.addCategoryObject('typeBinding', 'AbstractDQ_LogicalConsistency_Type', AbstractDQ_LogicalConsistency_Type)


# Complex type {http://www.isotc211.org/2005/gmd}DQ_LogicalConsistency_PropertyType with content type ELEMENT_ONLY
class DQ_LogicalConsistency_PropertyType (pyxb.binding.basis.complexTypeDefinition):
    """Complex type {http://www.isotc211.org/2005/gmd}DQ_LogicalConsistency_PropertyType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'DQ_LogicalConsistency_PropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 451, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.isotc211.org/2005/gmd}AbstractDQ_LogicalConsistency uses Python identifier AbstractDQ_LogicalConsistency
    __AbstractDQ_LogicalConsistency = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'AbstractDQ_LogicalConsistency'), 'AbstractDQ_LogicalConsistency', '__httpwww_isotc211_org2005gmd_DQ_LogicalConsistency_PropertyType_httpwww_isotc211_org2005gmdAbstractDQ_LogicalConsistency', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 449, 1), )

    
    AbstractDQ_LogicalConsistency = property(__AbstractDQ_LogicalConsistency.value, __AbstractDQ_LogicalConsistency.set, None, None)

    
    # Attribute uuidref uses Python identifier uuidref
    __uuidref = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'uuidref'), 'uuidref', '__httpwww_isotc211_org2005gmd_DQ_LogicalConsistency_PropertyType_uuidref', pyxb.binding.datatypes.string)
    __uuidref._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 30, 2)
    __uuidref._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 30, 2)
    
    uuidref = property(__uuidref.value, __uuidref.set, None, None)

    
    # Attribute {http://www.isotc211.org/2005/gco}nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gco, 'nilReason'), 'nilReason', '__httpwww_isotc211_org2005gmd_DQ_LogicalConsistency_PropertyType_httpwww_isotc211_org2005gconilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 33, 1)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 456, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}type uses Python identifier type
    __type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'type'), 'type', '__httpwww_isotc211_org2005gmd_DQ_LogicalConsistency_PropertyType_httpwww_w3_org1999xlinktype', _ImportedBinding_bindings_v1411_write__xlink.typeType, fixed=True, unicode_default='simple')
    __type._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 29, 1)
    __type._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 112, 2)
    
    type = property(__type.value, __type.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}href uses Python identifier href
    __href = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'href'), 'href', '__httpwww_isotc211_org2005gmd_DQ_LogicalConsistency_PropertyType_httpwww_w3_org1999xlinkhref', _ImportedBinding_bindings_v1411_write__xlink.hrefType)
    __href._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 42, 1)
    __href._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 113, 2)
    
    href = property(__href.value, __href.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}role uses Python identifier role
    __role = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'role'), 'role', '__httpwww_isotc211_org2005gmd_DQ_LogicalConsistency_PropertyType_httpwww_w3_org1999xlinkrole', _ImportedBinding_bindings_v1411_write__xlink.roleType)
    __role._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 48, 1)
    __role._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 114, 2)
    
    role = property(__role.value, __role.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}arcrole uses Python identifier arcrole
    __arcrole = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'arcrole'), 'arcrole', '__httpwww_isotc211_org2005gmd_DQ_LogicalConsistency_PropertyType_httpwww_w3_org1999xlinkarcrole', _ImportedBinding_bindings_v1411_write__xlink.arcroleType)
    __arcrole._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 56, 1)
    __arcrole._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 115, 2)
    
    arcrole = property(__arcrole.value, __arcrole.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}title uses Python identifier title
    __title = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'title'), 'title', '__httpwww_isotc211_org2005gmd_DQ_LogicalConsistency_PropertyType_httpwww_w3_org1999xlinktitle', _ImportedBinding_bindings_v1411_write__xlink.titleAttrType)
    __title._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 64, 1)
    __title._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 116, 2)
    
    title = property(__title.value, __title.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}show uses Python identifier show
    __show = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'show'), 'show', '__httpwww_isotc211_org2005gmd_DQ_LogicalConsistency_PropertyType_httpwww_w3_org1999xlinkshow', _ImportedBinding_bindings_v1411_write__xlink.showType)
    __show._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 70, 1)
    __show._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 117, 2)
    
    show = property(__show.value, __show.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}actuate uses Python identifier actuate
    __actuate = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'actuate'), 'actuate', '__httpwww_isotc211_org2005gmd_DQ_LogicalConsistency_PropertyType_httpwww_w3_org1999xlinkactuate', _ImportedBinding_bindings_v1411_write__xlink.actuateType)
    __actuate._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 82, 1)
    __actuate._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 118, 2)
    
    actuate = property(__actuate.value, __actuate.set, None, None)

    _ElementMap.update({
        __AbstractDQ_LogicalConsistency.name() : __AbstractDQ_LogicalConsistency
    })
    _AttributeMap.update({
        __uuidref.name() : __uuidref,
        __nilReason.name() : __nilReason,
        __type.name() : __type,
        __href.name() : __href,
        __role.name() : __role,
        __arcrole.name() : __arcrole,
        __title.name() : __title,
        __show.name() : __show,
        __actuate.name() : __actuate
    })
_module_typeBindings.DQ_LogicalConsistency_PropertyType = DQ_LogicalConsistency_PropertyType
_Namespace_gmd.addCategoryObject('typeBinding', 'DQ_LogicalConsistency_PropertyType', DQ_LogicalConsistency_PropertyType)


# Complex type {http://www.isotc211.org/2005/gmd}AbstractDQ_Completeness_Type with content type ELEMENT_ONLY
class AbstractDQ_Completeness_Type (AbstractDQ_Element_Type):
    """Complex type {http://www.isotc211.org/2005/gmd}AbstractDQ_Completeness_Type with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = True
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'AbstractDQ_Completeness_Type')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 459, 1)
    _ElementMap = AbstractDQ_Element_Type._ElementMap.copy()
    _AttributeMap = AbstractDQ_Element_Type._AttributeMap.copy()
    # Base type is AbstractDQ_Element_Type
    
    # Element nameOfMeasure ({http://www.isotc211.org/2005/gmd}nameOfMeasure) inherited from {http://www.isotc211.org/2005/gmd}AbstractDQ_Element_Type
    
    # Element measureIdentification ({http://www.isotc211.org/2005/gmd}measureIdentification) inherited from {http://www.isotc211.org/2005/gmd}AbstractDQ_Element_Type
    
    # Element measureDescription ({http://www.isotc211.org/2005/gmd}measureDescription) inherited from {http://www.isotc211.org/2005/gmd}AbstractDQ_Element_Type
    
    # Element evaluationMethodType ({http://www.isotc211.org/2005/gmd}evaluationMethodType) inherited from {http://www.isotc211.org/2005/gmd}AbstractDQ_Element_Type
    
    # Element evaluationMethodDescription ({http://www.isotc211.org/2005/gmd}evaluationMethodDescription) inherited from {http://www.isotc211.org/2005/gmd}AbstractDQ_Element_Type
    
    # Element evaluationProcedure ({http://www.isotc211.org/2005/gmd}evaluationProcedure) inherited from {http://www.isotc211.org/2005/gmd}AbstractDQ_Element_Type
    
    # Element dateTime ({http://www.isotc211.org/2005/gmd}dateTime) inherited from {http://www.isotc211.org/2005/gmd}AbstractDQ_Element_Type
    
    # Element result ({http://www.isotc211.org/2005/gmd}result) inherited from {http://www.isotc211.org/2005/gmd}AbstractDQ_Element_Type
    
    # Attribute id inherited from {http://www.isotc211.org/2005/gco}AbstractObject_Type
    
    # Attribute uuid inherited from {http://www.isotc211.org/2005/gco}AbstractObject_Type
    _ElementMap.update({
        
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.AbstractDQ_Completeness_Type = AbstractDQ_Completeness_Type
_Namespace_gmd.addCategoryObject('typeBinding', 'AbstractDQ_Completeness_Type', AbstractDQ_Completeness_Type)


# Complex type {http://www.isotc211.org/2005/gmd}DQ_Completeness_PropertyType with content type ELEMENT_ONLY
class DQ_Completeness_PropertyType (pyxb.binding.basis.complexTypeDefinition):
    """Complex type {http://www.isotc211.org/2005/gmd}DQ_Completeness_PropertyType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'DQ_Completeness_PropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 467, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.isotc211.org/2005/gmd}AbstractDQ_Completeness uses Python identifier AbstractDQ_Completeness
    __AbstractDQ_Completeness = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'AbstractDQ_Completeness'), 'AbstractDQ_Completeness', '__httpwww_isotc211_org2005gmd_DQ_Completeness_PropertyType_httpwww_isotc211_org2005gmdAbstractDQ_Completeness', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 465, 1), )

    
    AbstractDQ_Completeness = property(__AbstractDQ_Completeness.value, __AbstractDQ_Completeness.set, None, None)

    
    # Attribute uuidref uses Python identifier uuidref
    __uuidref = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'uuidref'), 'uuidref', '__httpwww_isotc211_org2005gmd_DQ_Completeness_PropertyType_uuidref', pyxb.binding.datatypes.string)
    __uuidref._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 30, 2)
    __uuidref._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 30, 2)
    
    uuidref = property(__uuidref.value, __uuidref.set, None, None)

    
    # Attribute {http://www.isotc211.org/2005/gco}nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gco, 'nilReason'), 'nilReason', '__httpwww_isotc211_org2005gmd_DQ_Completeness_PropertyType_httpwww_isotc211_org2005gconilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 33, 1)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 472, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}type uses Python identifier type
    __type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'type'), 'type', '__httpwww_isotc211_org2005gmd_DQ_Completeness_PropertyType_httpwww_w3_org1999xlinktype', _ImportedBinding_bindings_v1411_write__xlink.typeType, fixed=True, unicode_default='simple')
    __type._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 29, 1)
    __type._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 112, 2)
    
    type = property(__type.value, __type.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}href uses Python identifier href
    __href = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'href'), 'href', '__httpwww_isotc211_org2005gmd_DQ_Completeness_PropertyType_httpwww_w3_org1999xlinkhref', _ImportedBinding_bindings_v1411_write__xlink.hrefType)
    __href._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 42, 1)
    __href._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 113, 2)
    
    href = property(__href.value, __href.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}role uses Python identifier role
    __role = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'role'), 'role', '__httpwww_isotc211_org2005gmd_DQ_Completeness_PropertyType_httpwww_w3_org1999xlinkrole', _ImportedBinding_bindings_v1411_write__xlink.roleType)
    __role._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 48, 1)
    __role._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 114, 2)
    
    role = property(__role.value, __role.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}arcrole uses Python identifier arcrole
    __arcrole = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'arcrole'), 'arcrole', '__httpwww_isotc211_org2005gmd_DQ_Completeness_PropertyType_httpwww_w3_org1999xlinkarcrole', _ImportedBinding_bindings_v1411_write__xlink.arcroleType)
    __arcrole._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 56, 1)
    __arcrole._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 115, 2)
    
    arcrole = property(__arcrole.value, __arcrole.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}title uses Python identifier title
    __title = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'title'), 'title', '__httpwww_isotc211_org2005gmd_DQ_Completeness_PropertyType_httpwww_w3_org1999xlinktitle', _ImportedBinding_bindings_v1411_write__xlink.titleAttrType)
    __title._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 64, 1)
    __title._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 116, 2)
    
    title = property(__title.value, __title.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}show uses Python identifier show
    __show = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'show'), 'show', '__httpwww_isotc211_org2005gmd_DQ_Completeness_PropertyType_httpwww_w3_org1999xlinkshow', _ImportedBinding_bindings_v1411_write__xlink.showType)
    __show._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 70, 1)
    __show._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 117, 2)
    
    show = property(__show.value, __show.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}actuate uses Python identifier actuate
    __actuate = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'actuate'), 'actuate', '__httpwww_isotc211_org2005gmd_DQ_Completeness_PropertyType_httpwww_w3_org1999xlinkactuate', _ImportedBinding_bindings_v1411_write__xlink.actuateType)
    __actuate._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 82, 1)
    __actuate._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 118, 2)
    
    actuate = property(__actuate.value, __actuate.set, None, None)

    _ElementMap.update({
        __AbstractDQ_Completeness.name() : __AbstractDQ_Completeness
    })
    _AttributeMap.update({
        __uuidref.name() : __uuidref,
        __nilReason.name() : __nilReason,
        __type.name() : __type,
        __href.name() : __href,
        __role.name() : __role,
        __arcrole.name() : __arcrole,
        __title.name() : __title,
        __show.name() : __show,
        __actuate.name() : __actuate
    })
_module_typeBindings.DQ_Completeness_PropertyType = DQ_Completeness_PropertyType
_Namespace_gmd.addCategoryObject('typeBinding', 'DQ_Completeness_PropertyType', DQ_Completeness_PropertyType)


# Complex type {http://www.isotc211.org/2005/gmd}DQ_Element_PropertyType with content type ELEMENT_ONLY
class DQ_Element_PropertyType (pyxb.binding.basis.complexTypeDefinition):
    """Complex type {http://www.isotc211.org/2005/gmd}DQ_Element_PropertyType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'DQ_Element_PropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 494, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.isotc211.org/2005/gmd}AbstractDQ_Element uses Python identifier AbstractDQ_Element
    __AbstractDQ_Element = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'AbstractDQ_Element'), 'AbstractDQ_Element', '__httpwww_isotc211_org2005gmd_DQ_Element_PropertyType_httpwww_isotc211_org2005gmdAbstractDQ_Element', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 492, 1), )

    
    AbstractDQ_Element = property(__AbstractDQ_Element.value, __AbstractDQ_Element.set, None, None)

    
    # Attribute uuidref uses Python identifier uuidref
    __uuidref = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'uuidref'), 'uuidref', '__httpwww_isotc211_org2005gmd_DQ_Element_PropertyType_uuidref', pyxb.binding.datatypes.string)
    __uuidref._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 30, 2)
    __uuidref._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 30, 2)
    
    uuidref = property(__uuidref.value, __uuidref.set, None, None)

    
    # Attribute {http://www.isotc211.org/2005/gco}nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gco, 'nilReason'), 'nilReason', '__httpwww_isotc211_org2005gmd_DQ_Element_PropertyType_httpwww_isotc211_org2005gconilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 33, 1)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 499, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}type uses Python identifier type
    __type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'type'), 'type', '__httpwww_isotc211_org2005gmd_DQ_Element_PropertyType_httpwww_w3_org1999xlinktype', _ImportedBinding_bindings_v1411_write__xlink.typeType, fixed=True, unicode_default='simple')
    __type._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 29, 1)
    __type._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 112, 2)
    
    type = property(__type.value, __type.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}href uses Python identifier href
    __href = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'href'), 'href', '__httpwww_isotc211_org2005gmd_DQ_Element_PropertyType_httpwww_w3_org1999xlinkhref', _ImportedBinding_bindings_v1411_write__xlink.hrefType)
    __href._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 42, 1)
    __href._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 113, 2)
    
    href = property(__href.value, __href.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}role uses Python identifier role
    __role = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'role'), 'role', '__httpwww_isotc211_org2005gmd_DQ_Element_PropertyType_httpwww_w3_org1999xlinkrole', _ImportedBinding_bindings_v1411_write__xlink.roleType)
    __role._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 48, 1)
    __role._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 114, 2)
    
    role = property(__role.value, __role.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}arcrole uses Python identifier arcrole
    __arcrole = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'arcrole'), 'arcrole', '__httpwww_isotc211_org2005gmd_DQ_Element_PropertyType_httpwww_w3_org1999xlinkarcrole', _ImportedBinding_bindings_v1411_write__xlink.arcroleType)
    __arcrole._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 56, 1)
    __arcrole._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 115, 2)
    
    arcrole = property(__arcrole.value, __arcrole.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}title uses Python identifier title
    __title = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'title'), 'title', '__httpwww_isotc211_org2005gmd_DQ_Element_PropertyType_httpwww_w3_org1999xlinktitle', _ImportedBinding_bindings_v1411_write__xlink.titleAttrType)
    __title._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 64, 1)
    __title._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 116, 2)
    
    title = property(__title.value, __title.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}show uses Python identifier show
    __show = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'show'), 'show', '__httpwww_isotc211_org2005gmd_DQ_Element_PropertyType_httpwww_w3_org1999xlinkshow', _ImportedBinding_bindings_v1411_write__xlink.showType)
    __show._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 70, 1)
    __show._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 117, 2)
    
    show = property(__show.value, __show.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}actuate uses Python identifier actuate
    __actuate = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'actuate'), 'actuate', '__httpwww_isotc211_org2005gmd_DQ_Element_PropertyType_httpwww_w3_org1999xlinkactuate', _ImportedBinding_bindings_v1411_write__xlink.actuateType)
    __actuate._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 82, 1)
    __actuate._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 118, 2)
    
    actuate = property(__actuate.value, __actuate.set, None, None)

    _ElementMap.update({
        __AbstractDQ_Element.name() : __AbstractDQ_Element
    })
    _AttributeMap.update({
        __uuidref.name() : __uuidref,
        __nilReason.name() : __nilReason,
        __type.name() : __type,
        __href.name() : __href,
        __role.name() : __role,
        __arcrole.name() : __arcrole,
        __title.name() : __title,
        __show.name() : __show,
        __actuate.name() : __actuate
    })
_module_typeBindings.DQ_Element_PropertyType = DQ_Element_PropertyType
_Namespace_gmd.addCategoryObject('typeBinding', 'DQ_Element_PropertyType', DQ_Element_PropertyType)


# Complex type {http://www.isotc211.org/2005/gmd}DQ_DataQuality_PropertyType with content type ELEMENT_ONLY
class DQ_DataQuality_PropertyType (pyxb.binding.basis.complexTypeDefinition):
    """Complex type {http://www.isotc211.org/2005/gmd}DQ_DataQuality_PropertyType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'DQ_DataQuality_PropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 516, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.isotc211.org/2005/gmd}DQ_DataQuality uses Python identifier DQ_DataQuality
    __DQ_DataQuality = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'DQ_DataQuality'), 'DQ_DataQuality', '__httpwww_isotc211_org2005gmd_DQ_DataQuality_PropertyType_httpwww_isotc211_org2005gmdDQ_DataQuality', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 514, 1), )

    
    DQ_DataQuality = property(__DQ_DataQuality.value, __DQ_DataQuality.set, None, None)

    
    # Attribute uuidref uses Python identifier uuidref
    __uuidref = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'uuidref'), 'uuidref', '__httpwww_isotc211_org2005gmd_DQ_DataQuality_PropertyType_uuidref', pyxb.binding.datatypes.string)
    __uuidref._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 30, 2)
    __uuidref._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 30, 2)
    
    uuidref = property(__uuidref.value, __uuidref.set, None, None)

    
    # Attribute {http://www.isotc211.org/2005/gco}nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gco, 'nilReason'), 'nilReason', '__httpwww_isotc211_org2005gmd_DQ_DataQuality_PropertyType_httpwww_isotc211_org2005gconilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 33, 1)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 521, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}type uses Python identifier type
    __type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'type'), 'type', '__httpwww_isotc211_org2005gmd_DQ_DataQuality_PropertyType_httpwww_w3_org1999xlinktype', _ImportedBinding_bindings_v1411_write__xlink.typeType, fixed=True, unicode_default='simple')
    __type._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 29, 1)
    __type._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 112, 2)
    
    type = property(__type.value, __type.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}href uses Python identifier href
    __href = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'href'), 'href', '__httpwww_isotc211_org2005gmd_DQ_DataQuality_PropertyType_httpwww_w3_org1999xlinkhref', _ImportedBinding_bindings_v1411_write__xlink.hrefType)
    __href._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 42, 1)
    __href._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 113, 2)
    
    href = property(__href.value, __href.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}role uses Python identifier role
    __role = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'role'), 'role', '__httpwww_isotc211_org2005gmd_DQ_DataQuality_PropertyType_httpwww_w3_org1999xlinkrole', _ImportedBinding_bindings_v1411_write__xlink.roleType)
    __role._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 48, 1)
    __role._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 114, 2)
    
    role = property(__role.value, __role.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}arcrole uses Python identifier arcrole
    __arcrole = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'arcrole'), 'arcrole', '__httpwww_isotc211_org2005gmd_DQ_DataQuality_PropertyType_httpwww_w3_org1999xlinkarcrole', _ImportedBinding_bindings_v1411_write__xlink.arcroleType)
    __arcrole._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 56, 1)
    __arcrole._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 115, 2)
    
    arcrole = property(__arcrole.value, __arcrole.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}title uses Python identifier title
    __title = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'title'), 'title', '__httpwww_isotc211_org2005gmd_DQ_DataQuality_PropertyType_httpwww_w3_org1999xlinktitle', _ImportedBinding_bindings_v1411_write__xlink.titleAttrType)
    __title._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 64, 1)
    __title._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 116, 2)
    
    title = property(__title.value, __title.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}show uses Python identifier show
    __show = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'show'), 'show', '__httpwww_isotc211_org2005gmd_DQ_DataQuality_PropertyType_httpwww_w3_org1999xlinkshow', _ImportedBinding_bindings_v1411_write__xlink.showType)
    __show._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 70, 1)
    __show._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 117, 2)
    
    show = property(__show.value, __show.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}actuate uses Python identifier actuate
    __actuate = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'actuate'), 'actuate', '__httpwww_isotc211_org2005gmd_DQ_DataQuality_PropertyType_httpwww_w3_org1999xlinkactuate', _ImportedBinding_bindings_v1411_write__xlink.actuateType)
    __actuate._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 82, 1)
    __actuate._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 118, 2)
    
    actuate = property(__actuate.value, __actuate.set, None, None)

    _ElementMap.update({
        __DQ_DataQuality.name() : __DQ_DataQuality
    })
    _AttributeMap.update({
        __uuidref.name() : __uuidref,
        __nilReason.name() : __nilReason,
        __type.name() : __type,
        __href.name() : __href,
        __role.name() : __role,
        __arcrole.name() : __arcrole,
        __title.name() : __title,
        __show.name() : __show,
        __actuate.name() : __actuate
    })
_module_typeBindings.DQ_DataQuality_PropertyType = DQ_DataQuality_PropertyType
_Namespace_gmd.addCategoryObject('typeBinding', 'DQ_DataQuality_PropertyType', DQ_DataQuality_PropertyType)


# Complex type {http://www.isotc211.org/2005/gmd}DQ_Scope_PropertyType with content type ELEMENT_ONLY
class DQ_Scope_PropertyType (pyxb.binding.basis.complexTypeDefinition):
    """Complex type {http://www.isotc211.org/2005/gmd}DQ_Scope_PropertyType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'DQ_Scope_PropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 538, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.isotc211.org/2005/gmd}DQ_Scope uses Python identifier DQ_Scope
    __DQ_Scope = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'DQ_Scope'), 'DQ_Scope', '__httpwww_isotc211_org2005gmd_DQ_Scope_PropertyType_httpwww_isotc211_org2005gmdDQ_Scope', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 536, 1), )

    
    DQ_Scope = property(__DQ_Scope.value, __DQ_Scope.set, None, None)

    
    # Attribute uuidref uses Python identifier uuidref
    __uuidref = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'uuidref'), 'uuidref', '__httpwww_isotc211_org2005gmd_DQ_Scope_PropertyType_uuidref', pyxb.binding.datatypes.string)
    __uuidref._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 30, 2)
    __uuidref._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 30, 2)
    
    uuidref = property(__uuidref.value, __uuidref.set, None, None)

    
    # Attribute {http://www.isotc211.org/2005/gco}nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gco, 'nilReason'), 'nilReason', '__httpwww_isotc211_org2005gmd_DQ_Scope_PropertyType_httpwww_isotc211_org2005gconilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 33, 1)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 543, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}type uses Python identifier type
    __type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'type'), 'type', '__httpwww_isotc211_org2005gmd_DQ_Scope_PropertyType_httpwww_w3_org1999xlinktype', _ImportedBinding_bindings_v1411_write__xlink.typeType, fixed=True, unicode_default='simple')
    __type._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 29, 1)
    __type._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 112, 2)
    
    type = property(__type.value, __type.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}href uses Python identifier href
    __href = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'href'), 'href', '__httpwww_isotc211_org2005gmd_DQ_Scope_PropertyType_httpwww_w3_org1999xlinkhref', _ImportedBinding_bindings_v1411_write__xlink.hrefType)
    __href._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 42, 1)
    __href._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 113, 2)
    
    href = property(__href.value, __href.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}role uses Python identifier role
    __role = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'role'), 'role', '__httpwww_isotc211_org2005gmd_DQ_Scope_PropertyType_httpwww_w3_org1999xlinkrole', _ImportedBinding_bindings_v1411_write__xlink.roleType)
    __role._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 48, 1)
    __role._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 114, 2)
    
    role = property(__role.value, __role.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}arcrole uses Python identifier arcrole
    __arcrole = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'arcrole'), 'arcrole', '__httpwww_isotc211_org2005gmd_DQ_Scope_PropertyType_httpwww_w3_org1999xlinkarcrole', _ImportedBinding_bindings_v1411_write__xlink.arcroleType)
    __arcrole._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 56, 1)
    __arcrole._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 115, 2)
    
    arcrole = property(__arcrole.value, __arcrole.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}title uses Python identifier title
    __title = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'title'), 'title', '__httpwww_isotc211_org2005gmd_DQ_Scope_PropertyType_httpwww_w3_org1999xlinktitle', _ImportedBinding_bindings_v1411_write__xlink.titleAttrType)
    __title._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 64, 1)
    __title._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 116, 2)
    
    title = property(__title.value, __title.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}show uses Python identifier show
    __show = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'show'), 'show', '__httpwww_isotc211_org2005gmd_DQ_Scope_PropertyType_httpwww_w3_org1999xlinkshow', _ImportedBinding_bindings_v1411_write__xlink.showType)
    __show._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 70, 1)
    __show._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 117, 2)
    
    show = property(__show.value, __show.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}actuate uses Python identifier actuate
    __actuate = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'actuate'), 'actuate', '__httpwww_isotc211_org2005gmd_DQ_Scope_PropertyType_httpwww_w3_org1999xlinkactuate', _ImportedBinding_bindings_v1411_write__xlink.actuateType)
    __actuate._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 82, 1)
    __actuate._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 118, 2)
    
    actuate = property(__actuate.value, __actuate.set, None, None)

    _ElementMap.update({
        __DQ_Scope.name() : __DQ_Scope
    })
    _AttributeMap.update({
        __uuidref.name() : __uuidref,
        __nilReason.name() : __nilReason,
        __type.name() : __type,
        __href.name() : __href,
        __role.name() : __role,
        __arcrole.name() : __arcrole,
        __title.name() : __title,
        __show.name() : __show,
        __actuate.name() : __actuate
    })
_module_typeBindings.DQ_Scope_PropertyType = DQ_Scope_PropertyType
_Namespace_gmd.addCategoryObject('typeBinding', 'DQ_Scope_PropertyType', DQ_Scope_PropertyType)


# Complex type {http://www.isotc211.org/2005/gmd}DQ_EvaluationMethodTypeCode_PropertyType with content type ELEMENT_ONLY
class DQ_EvaluationMethodTypeCode_PropertyType (pyxb.binding.basis.complexTypeDefinition):
    """Complex type {http://www.isotc211.org/2005/gmd}DQ_EvaluationMethodTypeCode_PropertyType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'DQ_EvaluationMethodTypeCode_PropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 549, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.isotc211.org/2005/gmd}DQ_EvaluationMethodTypeCode uses Python identifier DQ_EvaluationMethodTypeCode
    __DQ_EvaluationMethodTypeCode = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'DQ_EvaluationMethodTypeCode'), 'DQ_EvaluationMethodTypeCode', '__httpwww_isotc211_org2005gmd_DQ_EvaluationMethodTypeCode_PropertyType_httpwww_isotc211_org2005gmdDQ_EvaluationMethodTypeCode', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 547, 1), )

    
    DQ_EvaluationMethodTypeCode = property(__DQ_EvaluationMethodTypeCode.value, __DQ_EvaluationMethodTypeCode.set, None, None)

    
    # Attribute {http://www.isotc211.org/2005/gco}nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gco, 'nilReason'), 'nilReason', '__httpwww_isotc211_org2005gmd_DQ_EvaluationMethodTypeCode_PropertyType_httpwww_isotc211_org2005gconilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 33, 1)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 553, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    _ElementMap.update({
        __DQ_EvaluationMethodTypeCode.name() : __DQ_EvaluationMethodTypeCode
    })
    _AttributeMap.update({
        __nilReason.name() : __nilReason
    })
_module_typeBindings.DQ_EvaluationMethodTypeCode_PropertyType = DQ_EvaluationMethodTypeCode_PropertyType
_Namespace_gmd.addCategoryObject('typeBinding', 'DQ_EvaluationMethodTypeCode_PropertyType', DQ_EvaluationMethodTypeCode_PropertyType)


# Complex type {http://www.isotc211.org/2005/gmd}MD_Medium_PropertyType with content type ELEMENT_ONLY
class MD_Medium_PropertyType (pyxb.binding.basis.complexTypeDefinition):
    """Complex type {http://www.isotc211.org/2005/gmd}MD_Medium_PropertyType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_Medium_PropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/distribution.xsd', 34, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.isotc211.org/2005/gmd}MD_Medium uses Python identifier MD_Medium
    __MD_Medium = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_Medium'), 'MD_Medium', '__httpwww_isotc211_org2005gmd_MD_Medium_PropertyType_httpwww_isotc211_org2005gmdMD_Medium', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/distribution.xsd', 32, 1), )

    
    MD_Medium = property(__MD_Medium.value, __MD_Medium.set, None, None)

    
    # Attribute uuidref uses Python identifier uuidref
    __uuidref = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'uuidref'), 'uuidref', '__httpwww_isotc211_org2005gmd_MD_Medium_PropertyType_uuidref', pyxb.binding.datatypes.string)
    __uuidref._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 30, 2)
    __uuidref._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 30, 2)
    
    uuidref = property(__uuidref.value, __uuidref.set, None, None)

    
    # Attribute {http://www.isotc211.org/2005/gco}nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gco, 'nilReason'), 'nilReason', '__httpwww_isotc211_org2005gmd_MD_Medium_PropertyType_httpwww_isotc211_org2005gconilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 33, 1)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/distribution.xsd', 39, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}type uses Python identifier type
    __type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'type'), 'type', '__httpwww_isotc211_org2005gmd_MD_Medium_PropertyType_httpwww_w3_org1999xlinktype', _ImportedBinding_bindings_v1411_write__xlink.typeType, fixed=True, unicode_default='simple')
    __type._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 29, 1)
    __type._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 112, 2)
    
    type = property(__type.value, __type.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}href uses Python identifier href
    __href = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'href'), 'href', '__httpwww_isotc211_org2005gmd_MD_Medium_PropertyType_httpwww_w3_org1999xlinkhref', _ImportedBinding_bindings_v1411_write__xlink.hrefType)
    __href._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 42, 1)
    __href._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 113, 2)
    
    href = property(__href.value, __href.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}role uses Python identifier role
    __role = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'role'), 'role', '__httpwww_isotc211_org2005gmd_MD_Medium_PropertyType_httpwww_w3_org1999xlinkrole', _ImportedBinding_bindings_v1411_write__xlink.roleType)
    __role._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 48, 1)
    __role._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 114, 2)
    
    role = property(__role.value, __role.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}arcrole uses Python identifier arcrole
    __arcrole = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'arcrole'), 'arcrole', '__httpwww_isotc211_org2005gmd_MD_Medium_PropertyType_httpwww_w3_org1999xlinkarcrole', _ImportedBinding_bindings_v1411_write__xlink.arcroleType)
    __arcrole._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 56, 1)
    __arcrole._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 115, 2)
    
    arcrole = property(__arcrole.value, __arcrole.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}title uses Python identifier title
    __title = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'title'), 'title', '__httpwww_isotc211_org2005gmd_MD_Medium_PropertyType_httpwww_w3_org1999xlinktitle', _ImportedBinding_bindings_v1411_write__xlink.titleAttrType)
    __title._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 64, 1)
    __title._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 116, 2)
    
    title = property(__title.value, __title.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}show uses Python identifier show
    __show = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'show'), 'show', '__httpwww_isotc211_org2005gmd_MD_Medium_PropertyType_httpwww_w3_org1999xlinkshow', _ImportedBinding_bindings_v1411_write__xlink.showType)
    __show._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 70, 1)
    __show._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 117, 2)
    
    show = property(__show.value, __show.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}actuate uses Python identifier actuate
    __actuate = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'actuate'), 'actuate', '__httpwww_isotc211_org2005gmd_MD_Medium_PropertyType_httpwww_w3_org1999xlinkactuate', _ImportedBinding_bindings_v1411_write__xlink.actuateType)
    __actuate._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 82, 1)
    __actuate._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 118, 2)
    
    actuate = property(__actuate.value, __actuate.set, None, None)

    _ElementMap.update({
        __MD_Medium.name() : __MD_Medium
    })
    _AttributeMap.update({
        __uuidref.name() : __uuidref,
        __nilReason.name() : __nilReason,
        __type.name() : __type,
        __href.name() : __href,
        __role.name() : __role,
        __arcrole.name() : __arcrole,
        __title.name() : __title,
        __show.name() : __show,
        __actuate.name() : __actuate
    })
_module_typeBindings.MD_Medium_PropertyType = MD_Medium_PropertyType
_Namespace_gmd.addCategoryObject('typeBinding', 'MD_Medium_PropertyType', MD_Medium_PropertyType)


# Complex type {http://www.isotc211.org/2005/gmd}MD_DigitalTransferOptions_PropertyType with content type ELEMENT_ONLY
class MD_DigitalTransferOptions_PropertyType (pyxb.binding.basis.complexTypeDefinition):
    """Complex type {http://www.isotc211.org/2005/gmd}MD_DigitalTransferOptions_PropertyType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_DigitalTransferOptions_PropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/distribution.xsd', 60, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.isotc211.org/2005/gmd}MD_DigitalTransferOptions uses Python identifier MD_DigitalTransferOptions
    __MD_DigitalTransferOptions = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_DigitalTransferOptions'), 'MD_DigitalTransferOptions', '__httpwww_isotc211_org2005gmd_MD_DigitalTransferOptions_PropertyType_httpwww_isotc211_org2005gmdMD_DigitalTransferOptions', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/distribution.xsd', 58, 1), )

    
    MD_DigitalTransferOptions = property(__MD_DigitalTransferOptions.value, __MD_DigitalTransferOptions.set, None, None)

    
    # Attribute uuidref uses Python identifier uuidref
    __uuidref = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'uuidref'), 'uuidref', '__httpwww_isotc211_org2005gmd_MD_DigitalTransferOptions_PropertyType_uuidref', pyxb.binding.datatypes.string)
    __uuidref._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 30, 2)
    __uuidref._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 30, 2)
    
    uuidref = property(__uuidref.value, __uuidref.set, None, None)

    
    # Attribute {http://www.isotc211.org/2005/gco}nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gco, 'nilReason'), 'nilReason', '__httpwww_isotc211_org2005gmd_MD_DigitalTransferOptions_PropertyType_httpwww_isotc211_org2005gconilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 33, 1)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/distribution.xsd', 65, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}type uses Python identifier type
    __type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'type'), 'type', '__httpwww_isotc211_org2005gmd_MD_DigitalTransferOptions_PropertyType_httpwww_w3_org1999xlinktype', _ImportedBinding_bindings_v1411_write__xlink.typeType, fixed=True, unicode_default='simple')
    __type._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 29, 1)
    __type._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 112, 2)
    
    type = property(__type.value, __type.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}href uses Python identifier href
    __href = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'href'), 'href', '__httpwww_isotc211_org2005gmd_MD_DigitalTransferOptions_PropertyType_httpwww_w3_org1999xlinkhref', _ImportedBinding_bindings_v1411_write__xlink.hrefType)
    __href._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 42, 1)
    __href._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 113, 2)
    
    href = property(__href.value, __href.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}role uses Python identifier role
    __role = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'role'), 'role', '__httpwww_isotc211_org2005gmd_MD_DigitalTransferOptions_PropertyType_httpwww_w3_org1999xlinkrole', _ImportedBinding_bindings_v1411_write__xlink.roleType)
    __role._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 48, 1)
    __role._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 114, 2)
    
    role = property(__role.value, __role.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}arcrole uses Python identifier arcrole
    __arcrole = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'arcrole'), 'arcrole', '__httpwww_isotc211_org2005gmd_MD_DigitalTransferOptions_PropertyType_httpwww_w3_org1999xlinkarcrole', _ImportedBinding_bindings_v1411_write__xlink.arcroleType)
    __arcrole._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 56, 1)
    __arcrole._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 115, 2)
    
    arcrole = property(__arcrole.value, __arcrole.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}title uses Python identifier title
    __title = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'title'), 'title', '__httpwww_isotc211_org2005gmd_MD_DigitalTransferOptions_PropertyType_httpwww_w3_org1999xlinktitle', _ImportedBinding_bindings_v1411_write__xlink.titleAttrType)
    __title._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 64, 1)
    __title._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 116, 2)
    
    title = property(__title.value, __title.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}show uses Python identifier show
    __show = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'show'), 'show', '__httpwww_isotc211_org2005gmd_MD_DigitalTransferOptions_PropertyType_httpwww_w3_org1999xlinkshow', _ImportedBinding_bindings_v1411_write__xlink.showType)
    __show._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 70, 1)
    __show._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 117, 2)
    
    show = property(__show.value, __show.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}actuate uses Python identifier actuate
    __actuate = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'actuate'), 'actuate', '__httpwww_isotc211_org2005gmd_MD_DigitalTransferOptions_PropertyType_httpwww_w3_org1999xlinkactuate', _ImportedBinding_bindings_v1411_write__xlink.actuateType)
    __actuate._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 82, 1)
    __actuate._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 118, 2)
    
    actuate = property(__actuate.value, __actuate.set, None, None)

    _ElementMap.update({
        __MD_DigitalTransferOptions.name() : __MD_DigitalTransferOptions
    })
    _AttributeMap.update({
        __uuidref.name() : __uuidref,
        __nilReason.name() : __nilReason,
        __type.name() : __type,
        __href.name() : __href,
        __role.name() : __role,
        __arcrole.name() : __arcrole,
        __title.name() : __title,
        __show.name() : __show,
        __actuate.name() : __actuate
    })
_module_typeBindings.MD_DigitalTransferOptions_PropertyType = MD_DigitalTransferOptions_PropertyType
_Namespace_gmd.addCategoryObject('typeBinding', 'MD_DigitalTransferOptions_PropertyType', MD_DigitalTransferOptions_PropertyType)


# Complex type {http://www.isotc211.org/2005/gmd}MD_StandardOrderProcess_PropertyType with content type ELEMENT_ONLY
class MD_StandardOrderProcess_PropertyType (pyxb.binding.basis.complexTypeDefinition):
    """Complex type {http://www.isotc211.org/2005/gmd}MD_StandardOrderProcess_PropertyType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_StandardOrderProcess_PropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/distribution.xsd', 86, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.isotc211.org/2005/gmd}MD_StandardOrderProcess uses Python identifier MD_StandardOrderProcess
    __MD_StandardOrderProcess = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_StandardOrderProcess'), 'MD_StandardOrderProcess', '__httpwww_isotc211_org2005gmd_MD_StandardOrderProcess_PropertyType_httpwww_isotc211_org2005gmdMD_StandardOrderProcess', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/distribution.xsd', 84, 1), )

    
    MD_StandardOrderProcess = property(__MD_StandardOrderProcess.value, __MD_StandardOrderProcess.set, None, None)

    
    # Attribute uuidref uses Python identifier uuidref
    __uuidref = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'uuidref'), 'uuidref', '__httpwww_isotc211_org2005gmd_MD_StandardOrderProcess_PropertyType_uuidref', pyxb.binding.datatypes.string)
    __uuidref._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 30, 2)
    __uuidref._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 30, 2)
    
    uuidref = property(__uuidref.value, __uuidref.set, None, None)

    
    # Attribute {http://www.isotc211.org/2005/gco}nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gco, 'nilReason'), 'nilReason', '__httpwww_isotc211_org2005gmd_MD_StandardOrderProcess_PropertyType_httpwww_isotc211_org2005gconilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 33, 1)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/distribution.xsd', 91, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}type uses Python identifier type
    __type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'type'), 'type', '__httpwww_isotc211_org2005gmd_MD_StandardOrderProcess_PropertyType_httpwww_w3_org1999xlinktype', _ImportedBinding_bindings_v1411_write__xlink.typeType, fixed=True, unicode_default='simple')
    __type._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 29, 1)
    __type._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 112, 2)
    
    type = property(__type.value, __type.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}href uses Python identifier href
    __href = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'href'), 'href', '__httpwww_isotc211_org2005gmd_MD_StandardOrderProcess_PropertyType_httpwww_w3_org1999xlinkhref', _ImportedBinding_bindings_v1411_write__xlink.hrefType)
    __href._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 42, 1)
    __href._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 113, 2)
    
    href = property(__href.value, __href.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}role uses Python identifier role
    __role = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'role'), 'role', '__httpwww_isotc211_org2005gmd_MD_StandardOrderProcess_PropertyType_httpwww_w3_org1999xlinkrole', _ImportedBinding_bindings_v1411_write__xlink.roleType)
    __role._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 48, 1)
    __role._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 114, 2)
    
    role = property(__role.value, __role.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}arcrole uses Python identifier arcrole
    __arcrole = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'arcrole'), 'arcrole', '__httpwww_isotc211_org2005gmd_MD_StandardOrderProcess_PropertyType_httpwww_w3_org1999xlinkarcrole', _ImportedBinding_bindings_v1411_write__xlink.arcroleType)
    __arcrole._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 56, 1)
    __arcrole._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 115, 2)
    
    arcrole = property(__arcrole.value, __arcrole.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}title uses Python identifier title
    __title = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'title'), 'title', '__httpwww_isotc211_org2005gmd_MD_StandardOrderProcess_PropertyType_httpwww_w3_org1999xlinktitle', _ImportedBinding_bindings_v1411_write__xlink.titleAttrType)
    __title._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 64, 1)
    __title._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 116, 2)
    
    title = property(__title.value, __title.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}show uses Python identifier show
    __show = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'show'), 'show', '__httpwww_isotc211_org2005gmd_MD_StandardOrderProcess_PropertyType_httpwww_w3_org1999xlinkshow', _ImportedBinding_bindings_v1411_write__xlink.showType)
    __show._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 70, 1)
    __show._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 117, 2)
    
    show = property(__show.value, __show.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}actuate uses Python identifier actuate
    __actuate = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'actuate'), 'actuate', '__httpwww_isotc211_org2005gmd_MD_StandardOrderProcess_PropertyType_httpwww_w3_org1999xlinkactuate', _ImportedBinding_bindings_v1411_write__xlink.actuateType)
    __actuate._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 82, 1)
    __actuate._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 118, 2)
    
    actuate = property(__actuate.value, __actuate.set, None, None)

    _ElementMap.update({
        __MD_StandardOrderProcess.name() : __MD_StandardOrderProcess
    })
    _AttributeMap.update({
        __uuidref.name() : __uuidref,
        __nilReason.name() : __nilReason,
        __type.name() : __type,
        __href.name() : __href,
        __role.name() : __role,
        __arcrole.name() : __arcrole,
        __title.name() : __title,
        __show.name() : __show,
        __actuate.name() : __actuate
    })
_module_typeBindings.MD_StandardOrderProcess_PropertyType = MD_StandardOrderProcess_PropertyType
_Namespace_gmd.addCategoryObject('typeBinding', 'MD_StandardOrderProcess_PropertyType', MD_StandardOrderProcess_PropertyType)


# Complex type {http://www.isotc211.org/2005/gmd}MD_Distributor_PropertyType with content type ELEMENT_ONLY
class MD_Distributor_PropertyType (pyxb.binding.basis.complexTypeDefinition):
    """Complex type {http://www.isotc211.org/2005/gmd}MD_Distributor_PropertyType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_Distributor_PropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/distribution.xsd', 112, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.isotc211.org/2005/gmd}MD_Distributor uses Python identifier MD_Distributor
    __MD_Distributor = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_Distributor'), 'MD_Distributor', '__httpwww_isotc211_org2005gmd_MD_Distributor_PropertyType_httpwww_isotc211_org2005gmdMD_Distributor', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/distribution.xsd', 110, 1), )

    
    MD_Distributor = property(__MD_Distributor.value, __MD_Distributor.set, None, None)

    
    # Attribute uuidref uses Python identifier uuidref
    __uuidref = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'uuidref'), 'uuidref', '__httpwww_isotc211_org2005gmd_MD_Distributor_PropertyType_uuidref', pyxb.binding.datatypes.string)
    __uuidref._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 30, 2)
    __uuidref._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 30, 2)
    
    uuidref = property(__uuidref.value, __uuidref.set, None, None)

    
    # Attribute {http://www.isotc211.org/2005/gco}nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gco, 'nilReason'), 'nilReason', '__httpwww_isotc211_org2005gmd_MD_Distributor_PropertyType_httpwww_isotc211_org2005gconilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 33, 1)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/distribution.xsd', 117, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}type uses Python identifier type
    __type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'type'), 'type', '__httpwww_isotc211_org2005gmd_MD_Distributor_PropertyType_httpwww_w3_org1999xlinktype', _ImportedBinding_bindings_v1411_write__xlink.typeType, fixed=True, unicode_default='simple')
    __type._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 29, 1)
    __type._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 112, 2)
    
    type = property(__type.value, __type.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}href uses Python identifier href
    __href = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'href'), 'href', '__httpwww_isotc211_org2005gmd_MD_Distributor_PropertyType_httpwww_w3_org1999xlinkhref', _ImportedBinding_bindings_v1411_write__xlink.hrefType)
    __href._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 42, 1)
    __href._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 113, 2)
    
    href = property(__href.value, __href.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}role uses Python identifier role
    __role = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'role'), 'role', '__httpwww_isotc211_org2005gmd_MD_Distributor_PropertyType_httpwww_w3_org1999xlinkrole', _ImportedBinding_bindings_v1411_write__xlink.roleType)
    __role._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 48, 1)
    __role._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 114, 2)
    
    role = property(__role.value, __role.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}arcrole uses Python identifier arcrole
    __arcrole = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'arcrole'), 'arcrole', '__httpwww_isotc211_org2005gmd_MD_Distributor_PropertyType_httpwww_w3_org1999xlinkarcrole', _ImportedBinding_bindings_v1411_write__xlink.arcroleType)
    __arcrole._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 56, 1)
    __arcrole._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 115, 2)
    
    arcrole = property(__arcrole.value, __arcrole.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}title uses Python identifier title
    __title = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'title'), 'title', '__httpwww_isotc211_org2005gmd_MD_Distributor_PropertyType_httpwww_w3_org1999xlinktitle', _ImportedBinding_bindings_v1411_write__xlink.titleAttrType)
    __title._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 64, 1)
    __title._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 116, 2)
    
    title = property(__title.value, __title.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}show uses Python identifier show
    __show = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'show'), 'show', '__httpwww_isotc211_org2005gmd_MD_Distributor_PropertyType_httpwww_w3_org1999xlinkshow', _ImportedBinding_bindings_v1411_write__xlink.showType)
    __show._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 70, 1)
    __show._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 117, 2)
    
    show = property(__show.value, __show.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}actuate uses Python identifier actuate
    __actuate = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'actuate'), 'actuate', '__httpwww_isotc211_org2005gmd_MD_Distributor_PropertyType_httpwww_w3_org1999xlinkactuate', _ImportedBinding_bindings_v1411_write__xlink.actuateType)
    __actuate._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 82, 1)
    __actuate._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 118, 2)
    
    actuate = property(__actuate.value, __actuate.set, None, None)

    _ElementMap.update({
        __MD_Distributor.name() : __MD_Distributor
    })
    _AttributeMap.update({
        __uuidref.name() : __uuidref,
        __nilReason.name() : __nilReason,
        __type.name() : __type,
        __href.name() : __href,
        __role.name() : __role,
        __arcrole.name() : __arcrole,
        __title.name() : __title,
        __show.name() : __show,
        __actuate.name() : __actuate
    })
_module_typeBindings.MD_Distributor_PropertyType = MD_Distributor_PropertyType
_Namespace_gmd.addCategoryObject('typeBinding', 'MD_Distributor_PropertyType', MD_Distributor_PropertyType)


# Complex type {http://www.isotc211.org/2005/gmd}MD_Distribution_PropertyType with content type ELEMENT_ONLY
class MD_Distribution_PropertyType (pyxb.binding.basis.complexTypeDefinition):
    """Complex type {http://www.isotc211.org/2005/gmd}MD_Distribution_PropertyType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_Distribution_PropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/distribution.xsd', 137, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.isotc211.org/2005/gmd}MD_Distribution uses Python identifier MD_Distribution
    __MD_Distribution = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_Distribution'), 'MD_Distribution', '__httpwww_isotc211_org2005gmd_MD_Distribution_PropertyType_httpwww_isotc211_org2005gmdMD_Distribution', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/distribution.xsd', 135, 1), )

    
    MD_Distribution = property(__MD_Distribution.value, __MD_Distribution.set, None, None)

    
    # Attribute uuidref uses Python identifier uuidref
    __uuidref = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'uuidref'), 'uuidref', '__httpwww_isotc211_org2005gmd_MD_Distribution_PropertyType_uuidref', pyxb.binding.datatypes.string)
    __uuidref._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 30, 2)
    __uuidref._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 30, 2)
    
    uuidref = property(__uuidref.value, __uuidref.set, None, None)

    
    # Attribute {http://www.isotc211.org/2005/gco}nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gco, 'nilReason'), 'nilReason', '__httpwww_isotc211_org2005gmd_MD_Distribution_PropertyType_httpwww_isotc211_org2005gconilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 33, 1)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/distribution.xsd', 142, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}type uses Python identifier type
    __type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'type'), 'type', '__httpwww_isotc211_org2005gmd_MD_Distribution_PropertyType_httpwww_w3_org1999xlinktype', _ImportedBinding_bindings_v1411_write__xlink.typeType, fixed=True, unicode_default='simple')
    __type._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 29, 1)
    __type._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 112, 2)
    
    type = property(__type.value, __type.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}href uses Python identifier href
    __href = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'href'), 'href', '__httpwww_isotc211_org2005gmd_MD_Distribution_PropertyType_httpwww_w3_org1999xlinkhref', _ImportedBinding_bindings_v1411_write__xlink.hrefType)
    __href._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 42, 1)
    __href._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 113, 2)
    
    href = property(__href.value, __href.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}role uses Python identifier role
    __role = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'role'), 'role', '__httpwww_isotc211_org2005gmd_MD_Distribution_PropertyType_httpwww_w3_org1999xlinkrole', _ImportedBinding_bindings_v1411_write__xlink.roleType)
    __role._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 48, 1)
    __role._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 114, 2)
    
    role = property(__role.value, __role.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}arcrole uses Python identifier arcrole
    __arcrole = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'arcrole'), 'arcrole', '__httpwww_isotc211_org2005gmd_MD_Distribution_PropertyType_httpwww_w3_org1999xlinkarcrole', _ImportedBinding_bindings_v1411_write__xlink.arcroleType)
    __arcrole._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 56, 1)
    __arcrole._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 115, 2)
    
    arcrole = property(__arcrole.value, __arcrole.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}title uses Python identifier title
    __title = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'title'), 'title', '__httpwww_isotc211_org2005gmd_MD_Distribution_PropertyType_httpwww_w3_org1999xlinktitle', _ImportedBinding_bindings_v1411_write__xlink.titleAttrType)
    __title._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 64, 1)
    __title._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 116, 2)
    
    title = property(__title.value, __title.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}show uses Python identifier show
    __show = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'show'), 'show', '__httpwww_isotc211_org2005gmd_MD_Distribution_PropertyType_httpwww_w3_org1999xlinkshow', _ImportedBinding_bindings_v1411_write__xlink.showType)
    __show._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 70, 1)
    __show._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 117, 2)
    
    show = property(__show.value, __show.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}actuate uses Python identifier actuate
    __actuate = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'actuate'), 'actuate', '__httpwww_isotc211_org2005gmd_MD_Distribution_PropertyType_httpwww_w3_org1999xlinkactuate', _ImportedBinding_bindings_v1411_write__xlink.actuateType)
    __actuate._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 82, 1)
    __actuate._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 118, 2)
    
    actuate = property(__actuate.value, __actuate.set, None, None)

    _ElementMap.update({
        __MD_Distribution.name() : __MD_Distribution
    })
    _AttributeMap.update({
        __uuidref.name() : __uuidref,
        __nilReason.name() : __nilReason,
        __type.name() : __type,
        __href.name() : __href,
        __role.name() : __role,
        __arcrole.name() : __arcrole,
        __title.name() : __title,
        __show.name() : __show,
        __actuate.name() : __actuate
    })
_module_typeBindings.MD_Distribution_PropertyType = MD_Distribution_PropertyType
_Namespace_gmd.addCategoryObject('typeBinding', 'MD_Distribution_PropertyType', MD_Distribution_PropertyType)


# Complex type {http://www.isotc211.org/2005/gmd}MD_Format_PropertyType with content type ELEMENT_ONLY
class MD_Format_PropertyType (pyxb.binding.basis.complexTypeDefinition):
    """Complex type {http://www.isotc211.org/2005/gmd}MD_Format_PropertyType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_Format_PropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/distribution.xsd', 165, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.isotc211.org/2005/gmd}MD_Format uses Python identifier MD_Format
    __MD_Format = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_Format'), 'MD_Format', '__httpwww_isotc211_org2005gmd_MD_Format_PropertyType_httpwww_isotc211_org2005gmdMD_Format', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/distribution.xsd', 163, 1), )

    
    MD_Format = property(__MD_Format.value, __MD_Format.set, None, None)

    
    # Attribute uuidref uses Python identifier uuidref
    __uuidref = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'uuidref'), 'uuidref', '__httpwww_isotc211_org2005gmd_MD_Format_PropertyType_uuidref', pyxb.binding.datatypes.string)
    __uuidref._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 30, 2)
    __uuidref._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 30, 2)
    
    uuidref = property(__uuidref.value, __uuidref.set, None, None)

    
    # Attribute {http://www.isotc211.org/2005/gco}nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gco, 'nilReason'), 'nilReason', '__httpwww_isotc211_org2005gmd_MD_Format_PropertyType_httpwww_isotc211_org2005gconilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 33, 1)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/distribution.xsd', 170, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}type uses Python identifier type
    __type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'type'), 'type', '__httpwww_isotc211_org2005gmd_MD_Format_PropertyType_httpwww_w3_org1999xlinktype', _ImportedBinding_bindings_v1411_write__xlink.typeType, fixed=True, unicode_default='simple')
    __type._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 29, 1)
    __type._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 112, 2)
    
    type = property(__type.value, __type.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}href uses Python identifier href
    __href = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'href'), 'href', '__httpwww_isotc211_org2005gmd_MD_Format_PropertyType_httpwww_w3_org1999xlinkhref', _ImportedBinding_bindings_v1411_write__xlink.hrefType)
    __href._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 42, 1)
    __href._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 113, 2)
    
    href = property(__href.value, __href.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}role uses Python identifier role
    __role = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'role'), 'role', '__httpwww_isotc211_org2005gmd_MD_Format_PropertyType_httpwww_w3_org1999xlinkrole', _ImportedBinding_bindings_v1411_write__xlink.roleType)
    __role._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 48, 1)
    __role._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 114, 2)
    
    role = property(__role.value, __role.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}arcrole uses Python identifier arcrole
    __arcrole = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'arcrole'), 'arcrole', '__httpwww_isotc211_org2005gmd_MD_Format_PropertyType_httpwww_w3_org1999xlinkarcrole', _ImportedBinding_bindings_v1411_write__xlink.arcroleType)
    __arcrole._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 56, 1)
    __arcrole._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 115, 2)
    
    arcrole = property(__arcrole.value, __arcrole.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}title uses Python identifier title
    __title = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'title'), 'title', '__httpwww_isotc211_org2005gmd_MD_Format_PropertyType_httpwww_w3_org1999xlinktitle', _ImportedBinding_bindings_v1411_write__xlink.titleAttrType)
    __title._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 64, 1)
    __title._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 116, 2)
    
    title = property(__title.value, __title.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}show uses Python identifier show
    __show = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'show'), 'show', '__httpwww_isotc211_org2005gmd_MD_Format_PropertyType_httpwww_w3_org1999xlinkshow', _ImportedBinding_bindings_v1411_write__xlink.showType)
    __show._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 70, 1)
    __show._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 117, 2)
    
    show = property(__show.value, __show.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}actuate uses Python identifier actuate
    __actuate = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'actuate'), 'actuate', '__httpwww_isotc211_org2005gmd_MD_Format_PropertyType_httpwww_w3_org1999xlinkactuate', _ImportedBinding_bindings_v1411_write__xlink.actuateType)
    __actuate._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 82, 1)
    __actuate._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 118, 2)
    
    actuate = property(__actuate.value, __actuate.set, None, None)

    _ElementMap.update({
        __MD_Format.name() : __MD_Format
    })
    _AttributeMap.update({
        __uuidref.name() : __uuidref,
        __nilReason.name() : __nilReason,
        __type.name() : __type,
        __href.name() : __href,
        __role.name() : __role,
        __arcrole.name() : __arcrole,
        __title.name() : __title,
        __show.name() : __show,
        __actuate.name() : __actuate
    })
_module_typeBindings.MD_Format_PropertyType = MD_Format_PropertyType
_Namespace_gmd.addCategoryObject('typeBinding', 'MD_Format_PropertyType', MD_Format_PropertyType)


# Complex type {http://www.isotc211.org/2005/gmd}MD_DistributionUnits_PropertyType with content type ELEMENT_ONLY
class MD_DistributionUnits_PropertyType (pyxb.binding.basis.complexTypeDefinition):
    """Complex type {http://www.isotc211.org/2005/gmd}MD_DistributionUnits_PropertyType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_DistributionUnits_PropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/distribution.xsd', 176, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.isotc211.org/2005/gmd}MD_DistributionUnits uses Python identifier MD_DistributionUnits
    __MD_DistributionUnits = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_DistributionUnits'), 'MD_DistributionUnits', '__httpwww_isotc211_org2005gmd_MD_DistributionUnits_PropertyType_httpwww_isotc211_org2005gmdMD_DistributionUnits', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/distribution.xsd', 174, 1), )

    
    MD_DistributionUnits = property(__MD_DistributionUnits.value, __MD_DistributionUnits.set, None, None)

    
    # Attribute {http://www.isotc211.org/2005/gco}nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gco, 'nilReason'), 'nilReason', '__httpwww_isotc211_org2005gmd_MD_DistributionUnits_PropertyType_httpwww_isotc211_org2005gconilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 33, 1)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/distribution.xsd', 180, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    _ElementMap.update({
        __MD_DistributionUnits.name() : __MD_DistributionUnits
    })
    _AttributeMap.update({
        __nilReason.name() : __nilReason
    })
_module_typeBindings.MD_DistributionUnits_PropertyType = MD_DistributionUnits_PropertyType
_Namespace_gmd.addCategoryObject('typeBinding', 'MD_DistributionUnits_PropertyType', MD_DistributionUnits_PropertyType)


# Complex type {http://www.isotc211.org/2005/gmd}MD_MediumFormatCode_PropertyType with content type ELEMENT_ONLY
class MD_MediumFormatCode_PropertyType (pyxb.binding.basis.complexTypeDefinition):
    """Complex type {http://www.isotc211.org/2005/gmd}MD_MediumFormatCode_PropertyType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_MediumFormatCode_PropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/distribution.xsd', 186, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.isotc211.org/2005/gmd}MD_MediumFormatCode uses Python identifier MD_MediumFormatCode
    __MD_MediumFormatCode = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_MediumFormatCode'), 'MD_MediumFormatCode', '__httpwww_isotc211_org2005gmd_MD_MediumFormatCode_PropertyType_httpwww_isotc211_org2005gmdMD_MediumFormatCode', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/distribution.xsd', 184, 1), )

    
    MD_MediumFormatCode = property(__MD_MediumFormatCode.value, __MD_MediumFormatCode.set, None, None)

    
    # Attribute {http://www.isotc211.org/2005/gco}nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gco, 'nilReason'), 'nilReason', '__httpwww_isotc211_org2005gmd_MD_MediumFormatCode_PropertyType_httpwww_isotc211_org2005gconilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 33, 1)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/distribution.xsd', 190, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    _ElementMap.update({
        __MD_MediumFormatCode.name() : __MD_MediumFormatCode
    })
    _AttributeMap.update({
        __nilReason.name() : __nilReason
    })
_module_typeBindings.MD_MediumFormatCode_PropertyType = MD_MediumFormatCode_PropertyType
_Namespace_gmd.addCategoryObject('typeBinding', 'MD_MediumFormatCode_PropertyType', MD_MediumFormatCode_PropertyType)


# Complex type {http://www.isotc211.org/2005/gmd}MD_MediumNameCode_PropertyType with content type ELEMENT_ONLY
class MD_MediumNameCode_PropertyType (pyxb.binding.basis.complexTypeDefinition):
    """Complex type {http://www.isotc211.org/2005/gmd}MD_MediumNameCode_PropertyType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_MediumNameCode_PropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/distribution.xsd', 196, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.isotc211.org/2005/gmd}MD_MediumNameCode uses Python identifier MD_MediumNameCode
    __MD_MediumNameCode = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_MediumNameCode'), 'MD_MediumNameCode', '__httpwww_isotc211_org2005gmd_MD_MediumNameCode_PropertyType_httpwww_isotc211_org2005gmdMD_MediumNameCode', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/distribution.xsd', 194, 1), )

    
    MD_MediumNameCode = property(__MD_MediumNameCode.value, __MD_MediumNameCode.set, None, None)

    
    # Attribute {http://www.isotc211.org/2005/gco}nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gco, 'nilReason'), 'nilReason', '__httpwww_isotc211_org2005gmd_MD_MediumNameCode_PropertyType_httpwww_isotc211_org2005gconilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 33, 1)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/distribution.xsd', 200, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    _ElementMap.update({
        __MD_MediumNameCode.name() : __MD_MediumNameCode
    })
    _AttributeMap.update({
        __nilReason.name() : __nilReason
    })
_module_typeBindings.MD_MediumNameCode_PropertyType = MD_MediumNameCode_PropertyType
_Namespace_gmd.addCategoryObject('typeBinding', 'MD_MediumNameCode_PropertyType', MD_MediumNameCode_PropertyType)


# Complex type {http://www.isotc211.org/2005/gmd}EX_TemporalExtent_PropertyType with content type ELEMENT_ONLY
class EX_TemporalExtent_PropertyType (pyxb.binding.basis.complexTypeDefinition):
    """Complex type {http://www.isotc211.org/2005/gmd}EX_TemporalExtent_PropertyType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'EX_TemporalExtent_PropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/extent.xsd', 32, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.isotc211.org/2005/gmd}EX_TemporalExtent uses Python identifier EX_TemporalExtent
    __EX_TemporalExtent = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'EX_TemporalExtent'), 'EX_TemporalExtent', '__httpwww_isotc211_org2005gmd_EX_TemporalExtent_PropertyType_httpwww_isotc211_org2005gmdEX_TemporalExtent', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/extent.xsd', 30, 1), )

    
    EX_TemporalExtent = property(__EX_TemporalExtent.value, __EX_TemporalExtent.set, None, None)

    
    # Attribute uuidref uses Python identifier uuidref
    __uuidref = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'uuidref'), 'uuidref', '__httpwww_isotc211_org2005gmd_EX_TemporalExtent_PropertyType_uuidref', pyxb.binding.datatypes.string)
    __uuidref._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 30, 2)
    __uuidref._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 30, 2)
    
    uuidref = property(__uuidref.value, __uuidref.set, None, None)

    
    # Attribute {http://www.isotc211.org/2005/gco}nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gco, 'nilReason'), 'nilReason', '__httpwww_isotc211_org2005gmd_EX_TemporalExtent_PropertyType_httpwww_isotc211_org2005gconilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 33, 1)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/extent.xsd', 37, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}type uses Python identifier type
    __type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'type'), 'type', '__httpwww_isotc211_org2005gmd_EX_TemporalExtent_PropertyType_httpwww_w3_org1999xlinktype', _ImportedBinding_bindings_v1411_write__xlink.typeType, fixed=True, unicode_default='simple')
    __type._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 29, 1)
    __type._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 112, 2)
    
    type = property(__type.value, __type.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}href uses Python identifier href
    __href = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'href'), 'href', '__httpwww_isotc211_org2005gmd_EX_TemporalExtent_PropertyType_httpwww_w3_org1999xlinkhref', _ImportedBinding_bindings_v1411_write__xlink.hrefType)
    __href._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 42, 1)
    __href._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 113, 2)
    
    href = property(__href.value, __href.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}role uses Python identifier role
    __role = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'role'), 'role', '__httpwww_isotc211_org2005gmd_EX_TemporalExtent_PropertyType_httpwww_w3_org1999xlinkrole', _ImportedBinding_bindings_v1411_write__xlink.roleType)
    __role._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 48, 1)
    __role._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 114, 2)
    
    role = property(__role.value, __role.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}arcrole uses Python identifier arcrole
    __arcrole = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'arcrole'), 'arcrole', '__httpwww_isotc211_org2005gmd_EX_TemporalExtent_PropertyType_httpwww_w3_org1999xlinkarcrole', _ImportedBinding_bindings_v1411_write__xlink.arcroleType)
    __arcrole._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 56, 1)
    __arcrole._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 115, 2)
    
    arcrole = property(__arcrole.value, __arcrole.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}title uses Python identifier title
    __title = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'title'), 'title', '__httpwww_isotc211_org2005gmd_EX_TemporalExtent_PropertyType_httpwww_w3_org1999xlinktitle', _ImportedBinding_bindings_v1411_write__xlink.titleAttrType)
    __title._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 64, 1)
    __title._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 116, 2)
    
    title = property(__title.value, __title.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}show uses Python identifier show
    __show = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'show'), 'show', '__httpwww_isotc211_org2005gmd_EX_TemporalExtent_PropertyType_httpwww_w3_org1999xlinkshow', _ImportedBinding_bindings_v1411_write__xlink.showType)
    __show._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 70, 1)
    __show._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 117, 2)
    
    show = property(__show.value, __show.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}actuate uses Python identifier actuate
    __actuate = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'actuate'), 'actuate', '__httpwww_isotc211_org2005gmd_EX_TemporalExtent_PropertyType_httpwww_w3_org1999xlinkactuate', _ImportedBinding_bindings_v1411_write__xlink.actuateType)
    __actuate._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 82, 1)
    __actuate._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 118, 2)
    
    actuate = property(__actuate.value, __actuate.set, None, None)

    _ElementMap.update({
        __EX_TemporalExtent.name() : __EX_TemporalExtent
    })
    _AttributeMap.update({
        __uuidref.name() : __uuidref,
        __nilReason.name() : __nilReason,
        __type.name() : __type,
        __href.name() : __href,
        __role.name() : __role,
        __arcrole.name() : __arcrole,
        __title.name() : __title,
        __show.name() : __show,
        __actuate.name() : __actuate
    })
_module_typeBindings.EX_TemporalExtent_PropertyType = EX_TemporalExtent_PropertyType
_Namespace_gmd.addCategoryObject('typeBinding', 'EX_TemporalExtent_PropertyType', EX_TemporalExtent_PropertyType)


# Complex type {http://www.isotc211.org/2005/gmd}EX_VerticalExtent_PropertyType with content type ELEMENT_ONLY
class EX_VerticalExtent_PropertyType (pyxb.binding.basis.complexTypeDefinition):
    """Complex type {http://www.isotc211.org/2005/gmd}EX_VerticalExtent_PropertyType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'EX_VerticalExtent_PropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/extent.xsd', 57, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.isotc211.org/2005/gmd}EX_VerticalExtent uses Python identifier EX_VerticalExtent
    __EX_VerticalExtent = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'EX_VerticalExtent'), 'EX_VerticalExtent', '__httpwww_isotc211_org2005gmd_EX_VerticalExtent_PropertyType_httpwww_isotc211_org2005gmdEX_VerticalExtent', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/extent.xsd', 55, 1), )

    
    EX_VerticalExtent = property(__EX_VerticalExtent.value, __EX_VerticalExtent.set, None, None)

    
    # Attribute uuidref uses Python identifier uuidref
    __uuidref = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'uuidref'), 'uuidref', '__httpwww_isotc211_org2005gmd_EX_VerticalExtent_PropertyType_uuidref', pyxb.binding.datatypes.string)
    __uuidref._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 30, 2)
    __uuidref._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 30, 2)
    
    uuidref = property(__uuidref.value, __uuidref.set, None, None)

    
    # Attribute {http://www.isotc211.org/2005/gco}nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gco, 'nilReason'), 'nilReason', '__httpwww_isotc211_org2005gmd_EX_VerticalExtent_PropertyType_httpwww_isotc211_org2005gconilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 33, 1)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/extent.xsd', 62, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}type uses Python identifier type
    __type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'type'), 'type', '__httpwww_isotc211_org2005gmd_EX_VerticalExtent_PropertyType_httpwww_w3_org1999xlinktype', _ImportedBinding_bindings_v1411_write__xlink.typeType, fixed=True, unicode_default='simple')
    __type._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 29, 1)
    __type._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 112, 2)
    
    type = property(__type.value, __type.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}href uses Python identifier href
    __href = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'href'), 'href', '__httpwww_isotc211_org2005gmd_EX_VerticalExtent_PropertyType_httpwww_w3_org1999xlinkhref', _ImportedBinding_bindings_v1411_write__xlink.hrefType)
    __href._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 42, 1)
    __href._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 113, 2)
    
    href = property(__href.value, __href.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}role uses Python identifier role
    __role = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'role'), 'role', '__httpwww_isotc211_org2005gmd_EX_VerticalExtent_PropertyType_httpwww_w3_org1999xlinkrole', _ImportedBinding_bindings_v1411_write__xlink.roleType)
    __role._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 48, 1)
    __role._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 114, 2)
    
    role = property(__role.value, __role.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}arcrole uses Python identifier arcrole
    __arcrole = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'arcrole'), 'arcrole', '__httpwww_isotc211_org2005gmd_EX_VerticalExtent_PropertyType_httpwww_w3_org1999xlinkarcrole', _ImportedBinding_bindings_v1411_write__xlink.arcroleType)
    __arcrole._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 56, 1)
    __arcrole._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 115, 2)
    
    arcrole = property(__arcrole.value, __arcrole.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}title uses Python identifier title
    __title = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'title'), 'title', '__httpwww_isotc211_org2005gmd_EX_VerticalExtent_PropertyType_httpwww_w3_org1999xlinktitle', _ImportedBinding_bindings_v1411_write__xlink.titleAttrType)
    __title._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 64, 1)
    __title._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 116, 2)
    
    title = property(__title.value, __title.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}show uses Python identifier show
    __show = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'show'), 'show', '__httpwww_isotc211_org2005gmd_EX_VerticalExtent_PropertyType_httpwww_w3_org1999xlinkshow', _ImportedBinding_bindings_v1411_write__xlink.showType)
    __show._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 70, 1)
    __show._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 117, 2)
    
    show = property(__show.value, __show.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}actuate uses Python identifier actuate
    __actuate = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'actuate'), 'actuate', '__httpwww_isotc211_org2005gmd_EX_VerticalExtent_PropertyType_httpwww_w3_org1999xlinkactuate', _ImportedBinding_bindings_v1411_write__xlink.actuateType)
    __actuate._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 82, 1)
    __actuate._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 118, 2)
    
    actuate = property(__actuate.value, __actuate.set, None, None)

    _ElementMap.update({
        __EX_VerticalExtent.name() : __EX_VerticalExtent
    })
    _AttributeMap.update({
        __uuidref.name() : __uuidref,
        __nilReason.name() : __nilReason,
        __type.name() : __type,
        __href.name() : __href,
        __role.name() : __role,
        __arcrole.name() : __arcrole,
        __title.name() : __title,
        __show.name() : __show,
        __actuate.name() : __actuate
    })
_module_typeBindings.EX_VerticalExtent_PropertyType = EX_VerticalExtent_PropertyType
_Namespace_gmd.addCategoryObject('typeBinding', 'EX_VerticalExtent_PropertyType', EX_VerticalExtent_PropertyType)


# Complex type {http://www.isotc211.org/2005/gmd}EX_BoundingPolygon_Type with content type ELEMENT_ONLY
class EX_BoundingPolygon_Type (AbstractEX_GeographicExtent_Type):
    """Boundary enclosing the dataset expressed as the closed set of (x,y) coordinates of the polygon (last point replicates first point)"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'EX_BoundingPolygon_Type')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/extent.xsd', 65, 1)
    _ElementMap = AbstractEX_GeographicExtent_Type._ElementMap.copy()
    _AttributeMap = AbstractEX_GeographicExtent_Type._AttributeMap.copy()
    # Base type is AbstractEX_GeographicExtent_Type
    
    # Element {http://www.isotc211.org/2005/gmd}polygon uses Python identifier polygon
    __polygon = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'polygon'), 'polygon', '__httpwww_isotc211_org2005gmd_EX_BoundingPolygon_Type_httpwww_isotc211_org2005gmdpolygon', True, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/extent.xsd', 72, 5), )

    
    polygon = property(__polygon.value, __polygon.set, None, None)

    
    # Element extentTypeCode ({http://www.isotc211.org/2005/gmd}extentTypeCode) inherited from {http://www.isotc211.org/2005/gmd}AbstractEX_GeographicExtent_Type
    
    # Attribute id inherited from {http://www.isotc211.org/2005/gco}AbstractObject_Type
    
    # Attribute uuid inherited from {http://www.isotc211.org/2005/gco}AbstractObject_Type
    _ElementMap.update({
        __polygon.name() : __polygon
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.EX_BoundingPolygon_Type = EX_BoundingPolygon_Type
_Namespace_gmd.addCategoryObject('typeBinding', 'EX_BoundingPolygon_Type', EX_BoundingPolygon_Type)


# Complex type {http://www.isotc211.org/2005/gmd}EX_BoundingPolygon_PropertyType with content type ELEMENT_ONLY
class EX_BoundingPolygon_PropertyType (pyxb.binding.basis.complexTypeDefinition):
    """Complex type {http://www.isotc211.org/2005/gmd}EX_BoundingPolygon_PropertyType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'EX_BoundingPolygon_PropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/extent.xsd', 80, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.isotc211.org/2005/gmd}EX_BoundingPolygon uses Python identifier EX_BoundingPolygon
    __EX_BoundingPolygon = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'EX_BoundingPolygon'), 'EX_BoundingPolygon', '__httpwww_isotc211_org2005gmd_EX_BoundingPolygon_PropertyType_httpwww_isotc211_org2005gmdEX_BoundingPolygon', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/extent.xsd', 78, 1), )

    
    EX_BoundingPolygon = property(__EX_BoundingPolygon.value, __EX_BoundingPolygon.set, None, None)

    
    # Attribute uuidref uses Python identifier uuidref
    __uuidref = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'uuidref'), 'uuidref', '__httpwww_isotc211_org2005gmd_EX_BoundingPolygon_PropertyType_uuidref', pyxb.binding.datatypes.string)
    __uuidref._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 30, 2)
    __uuidref._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 30, 2)
    
    uuidref = property(__uuidref.value, __uuidref.set, None, None)

    
    # Attribute {http://www.isotc211.org/2005/gco}nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gco, 'nilReason'), 'nilReason', '__httpwww_isotc211_org2005gmd_EX_BoundingPolygon_PropertyType_httpwww_isotc211_org2005gconilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 33, 1)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/extent.xsd', 85, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}type uses Python identifier type
    __type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'type'), 'type', '__httpwww_isotc211_org2005gmd_EX_BoundingPolygon_PropertyType_httpwww_w3_org1999xlinktype', _ImportedBinding_bindings_v1411_write__xlink.typeType, fixed=True, unicode_default='simple')
    __type._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 29, 1)
    __type._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 112, 2)
    
    type = property(__type.value, __type.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}href uses Python identifier href
    __href = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'href'), 'href', '__httpwww_isotc211_org2005gmd_EX_BoundingPolygon_PropertyType_httpwww_w3_org1999xlinkhref', _ImportedBinding_bindings_v1411_write__xlink.hrefType)
    __href._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 42, 1)
    __href._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 113, 2)
    
    href = property(__href.value, __href.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}role uses Python identifier role
    __role = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'role'), 'role', '__httpwww_isotc211_org2005gmd_EX_BoundingPolygon_PropertyType_httpwww_w3_org1999xlinkrole', _ImportedBinding_bindings_v1411_write__xlink.roleType)
    __role._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 48, 1)
    __role._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 114, 2)
    
    role = property(__role.value, __role.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}arcrole uses Python identifier arcrole
    __arcrole = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'arcrole'), 'arcrole', '__httpwww_isotc211_org2005gmd_EX_BoundingPolygon_PropertyType_httpwww_w3_org1999xlinkarcrole', _ImportedBinding_bindings_v1411_write__xlink.arcroleType)
    __arcrole._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 56, 1)
    __arcrole._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 115, 2)
    
    arcrole = property(__arcrole.value, __arcrole.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}title uses Python identifier title
    __title = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'title'), 'title', '__httpwww_isotc211_org2005gmd_EX_BoundingPolygon_PropertyType_httpwww_w3_org1999xlinktitle', _ImportedBinding_bindings_v1411_write__xlink.titleAttrType)
    __title._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 64, 1)
    __title._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 116, 2)
    
    title = property(__title.value, __title.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}show uses Python identifier show
    __show = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'show'), 'show', '__httpwww_isotc211_org2005gmd_EX_BoundingPolygon_PropertyType_httpwww_w3_org1999xlinkshow', _ImportedBinding_bindings_v1411_write__xlink.showType)
    __show._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 70, 1)
    __show._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 117, 2)
    
    show = property(__show.value, __show.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}actuate uses Python identifier actuate
    __actuate = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'actuate'), 'actuate', '__httpwww_isotc211_org2005gmd_EX_BoundingPolygon_PropertyType_httpwww_w3_org1999xlinkactuate', _ImportedBinding_bindings_v1411_write__xlink.actuateType)
    __actuate._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 82, 1)
    __actuate._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 118, 2)
    
    actuate = property(__actuate.value, __actuate.set, None, None)

    _ElementMap.update({
        __EX_BoundingPolygon.name() : __EX_BoundingPolygon
    })
    _AttributeMap.update({
        __uuidref.name() : __uuidref,
        __nilReason.name() : __nilReason,
        __type.name() : __type,
        __href.name() : __href,
        __role.name() : __role,
        __arcrole.name() : __arcrole,
        __title.name() : __title,
        __show.name() : __show,
        __actuate.name() : __actuate
    })
_module_typeBindings.EX_BoundingPolygon_PropertyType = EX_BoundingPolygon_PropertyType
_Namespace_gmd.addCategoryObject('typeBinding', 'EX_BoundingPolygon_PropertyType', EX_BoundingPolygon_PropertyType)


# Complex type {http://www.isotc211.org/2005/gmd}EX_Extent_PropertyType with content type ELEMENT_ONLY
class EX_Extent_PropertyType (pyxb.binding.basis.complexTypeDefinition):
    """Complex type {http://www.isotc211.org/2005/gmd}EX_Extent_PropertyType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'EX_Extent_PropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/extent.xsd', 106, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.isotc211.org/2005/gmd}EX_Extent uses Python identifier EX_Extent
    __EX_Extent = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'EX_Extent'), 'EX_Extent', '__httpwww_isotc211_org2005gmd_EX_Extent_PropertyType_httpwww_isotc211_org2005gmdEX_Extent', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/extent.xsd', 104, 1), )

    
    EX_Extent = property(__EX_Extent.value, __EX_Extent.set, None, None)

    
    # Attribute uuidref uses Python identifier uuidref
    __uuidref = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'uuidref'), 'uuidref', '__httpwww_isotc211_org2005gmd_EX_Extent_PropertyType_uuidref', pyxb.binding.datatypes.string)
    __uuidref._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 30, 2)
    __uuidref._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 30, 2)
    
    uuidref = property(__uuidref.value, __uuidref.set, None, None)

    
    # Attribute {http://www.isotc211.org/2005/gco}nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gco, 'nilReason'), 'nilReason', '__httpwww_isotc211_org2005gmd_EX_Extent_PropertyType_httpwww_isotc211_org2005gconilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 33, 1)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/extent.xsd', 111, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}type uses Python identifier type
    __type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'type'), 'type', '__httpwww_isotc211_org2005gmd_EX_Extent_PropertyType_httpwww_w3_org1999xlinktype', _ImportedBinding_bindings_v1411_write__xlink.typeType, fixed=True, unicode_default='simple')
    __type._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 29, 1)
    __type._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 112, 2)
    
    type = property(__type.value, __type.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}href uses Python identifier href
    __href = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'href'), 'href', '__httpwww_isotc211_org2005gmd_EX_Extent_PropertyType_httpwww_w3_org1999xlinkhref', _ImportedBinding_bindings_v1411_write__xlink.hrefType)
    __href._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 42, 1)
    __href._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 113, 2)
    
    href = property(__href.value, __href.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}role uses Python identifier role
    __role = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'role'), 'role', '__httpwww_isotc211_org2005gmd_EX_Extent_PropertyType_httpwww_w3_org1999xlinkrole', _ImportedBinding_bindings_v1411_write__xlink.roleType)
    __role._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 48, 1)
    __role._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 114, 2)
    
    role = property(__role.value, __role.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}arcrole uses Python identifier arcrole
    __arcrole = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'arcrole'), 'arcrole', '__httpwww_isotc211_org2005gmd_EX_Extent_PropertyType_httpwww_w3_org1999xlinkarcrole', _ImportedBinding_bindings_v1411_write__xlink.arcroleType)
    __arcrole._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 56, 1)
    __arcrole._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 115, 2)
    
    arcrole = property(__arcrole.value, __arcrole.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}title uses Python identifier title
    __title = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'title'), 'title', '__httpwww_isotc211_org2005gmd_EX_Extent_PropertyType_httpwww_w3_org1999xlinktitle', _ImportedBinding_bindings_v1411_write__xlink.titleAttrType)
    __title._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 64, 1)
    __title._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 116, 2)
    
    title = property(__title.value, __title.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}show uses Python identifier show
    __show = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'show'), 'show', '__httpwww_isotc211_org2005gmd_EX_Extent_PropertyType_httpwww_w3_org1999xlinkshow', _ImportedBinding_bindings_v1411_write__xlink.showType)
    __show._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 70, 1)
    __show._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 117, 2)
    
    show = property(__show.value, __show.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}actuate uses Python identifier actuate
    __actuate = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'actuate'), 'actuate', '__httpwww_isotc211_org2005gmd_EX_Extent_PropertyType_httpwww_w3_org1999xlinkactuate', _ImportedBinding_bindings_v1411_write__xlink.actuateType)
    __actuate._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 82, 1)
    __actuate._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 118, 2)
    
    actuate = property(__actuate.value, __actuate.set, None, None)

    _ElementMap.update({
        __EX_Extent.name() : __EX_Extent
    })
    _AttributeMap.update({
        __uuidref.name() : __uuidref,
        __nilReason.name() : __nilReason,
        __type.name() : __type,
        __href.name() : __href,
        __role.name() : __role,
        __arcrole.name() : __arcrole,
        __title.name() : __title,
        __show.name() : __show,
        __actuate.name() : __actuate
    })
_module_typeBindings.EX_Extent_PropertyType = EX_Extent_PropertyType
_Namespace_gmd.addCategoryObject('typeBinding', 'EX_Extent_PropertyType', EX_Extent_PropertyType)


# Complex type {http://www.isotc211.org/2005/gmd}EX_GeographicExtent_PropertyType with content type ELEMENT_ONLY
class EX_GeographicExtent_PropertyType (pyxb.binding.basis.complexTypeDefinition):
    """Complex type {http://www.isotc211.org/2005/gmd}EX_GeographicExtent_PropertyType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'EX_GeographicExtent_PropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/extent.xsd', 129, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.isotc211.org/2005/gmd}AbstractEX_GeographicExtent uses Python identifier AbstractEX_GeographicExtent
    __AbstractEX_GeographicExtent = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'AbstractEX_GeographicExtent'), 'AbstractEX_GeographicExtent', '__httpwww_isotc211_org2005gmd_EX_GeographicExtent_PropertyType_httpwww_isotc211_org2005gmdAbstractEX_GeographicExtent', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/extent.xsd', 127, 1), )

    
    AbstractEX_GeographicExtent = property(__AbstractEX_GeographicExtent.value, __AbstractEX_GeographicExtent.set, None, None)

    
    # Attribute uuidref uses Python identifier uuidref
    __uuidref = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'uuidref'), 'uuidref', '__httpwww_isotc211_org2005gmd_EX_GeographicExtent_PropertyType_uuidref', pyxb.binding.datatypes.string)
    __uuidref._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 30, 2)
    __uuidref._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 30, 2)
    
    uuidref = property(__uuidref.value, __uuidref.set, None, None)

    
    # Attribute {http://www.isotc211.org/2005/gco}nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gco, 'nilReason'), 'nilReason', '__httpwww_isotc211_org2005gmd_EX_GeographicExtent_PropertyType_httpwww_isotc211_org2005gconilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 33, 1)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/extent.xsd', 134, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}type uses Python identifier type
    __type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'type'), 'type', '__httpwww_isotc211_org2005gmd_EX_GeographicExtent_PropertyType_httpwww_w3_org1999xlinktype', _ImportedBinding_bindings_v1411_write__xlink.typeType, fixed=True, unicode_default='simple')
    __type._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 29, 1)
    __type._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 112, 2)
    
    type = property(__type.value, __type.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}href uses Python identifier href
    __href = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'href'), 'href', '__httpwww_isotc211_org2005gmd_EX_GeographicExtent_PropertyType_httpwww_w3_org1999xlinkhref', _ImportedBinding_bindings_v1411_write__xlink.hrefType)
    __href._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 42, 1)
    __href._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 113, 2)
    
    href = property(__href.value, __href.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}role uses Python identifier role
    __role = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'role'), 'role', '__httpwww_isotc211_org2005gmd_EX_GeographicExtent_PropertyType_httpwww_w3_org1999xlinkrole', _ImportedBinding_bindings_v1411_write__xlink.roleType)
    __role._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 48, 1)
    __role._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 114, 2)
    
    role = property(__role.value, __role.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}arcrole uses Python identifier arcrole
    __arcrole = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'arcrole'), 'arcrole', '__httpwww_isotc211_org2005gmd_EX_GeographicExtent_PropertyType_httpwww_w3_org1999xlinkarcrole', _ImportedBinding_bindings_v1411_write__xlink.arcroleType)
    __arcrole._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 56, 1)
    __arcrole._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 115, 2)
    
    arcrole = property(__arcrole.value, __arcrole.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}title uses Python identifier title
    __title = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'title'), 'title', '__httpwww_isotc211_org2005gmd_EX_GeographicExtent_PropertyType_httpwww_w3_org1999xlinktitle', _ImportedBinding_bindings_v1411_write__xlink.titleAttrType)
    __title._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 64, 1)
    __title._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 116, 2)
    
    title = property(__title.value, __title.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}show uses Python identifier show
    __show = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'show'), 'show', '__httpwww_isotc211_org2005gmd_EX_GeographicExtent_PropertyType_httpwww_w3_org1999xlinkshow', _ImportedBinding_bindings_v1411_write__xlink.showType)
    __show._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 70, 1)
    __show._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 117, 2)
    
    show = property(__show.value, __show.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}actuate uses Python identifier actuate
    __actuate = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'actuate'), 'actuate', '__httpwww_isotc211_org2005gmd_EX_GeographicExtent_PropertyType_httpwww_w3_org1999xlinkactuate', _ImportedBinding_bindings_v1411_write__xlink.actuateType)
    __actuate._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 82, 1)
    __actuate._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 118, 2)
    
    actuate = property(__actuate.value, __actuate.set, None, None)

    _ElementMap.update({
        __AbstractEX_GeographicExtent.name() : __AbstractEX_GeographicExtent
    })
    _AttributeMap.update({
        __uuidref.name() : __uuidref,
        __nilReason.name() : __nilReason,
        __type.name() : __type,
        __href.name() : __href,
        __role.name() : __role,
        __arcrole.name() : __arcrole,
        __title.name() : __title,
        __show.name() : __show,
        __actuate.name() : __actuate
    })
_module_typeBindings.EX_GeographicExtent_PropertyType = EX_GeographicExtent_PropertyType
_Namespace_gmd.addCategoryObject('typeBinding', 'EX_GeographicExtent_PropertyType', EX_GeographicExtent_PropertyType)


# Complex type {http://www.isotc211.org/2005/gmd}EX_GeographicBoundingBox_Type with content type ELEMENT_ONLY
class EX_GeographicBoundingBox_Type (AbstractEX_GeographicExtent_Type):
    """Geographic area of the entire dataset referenced to WGS 84"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'EX_GeographicBoundingBox_Type')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/extent.xsd', 137, 1)
    _ElementMap = AbstractEX_GeographicExtent_Type._ElementMap.copy()
    _AttributeMap = AbstractEX_GeographicExtent_Type._AttributeMap.copy()
    # Base type is AbstractEX_GeographicExtent_Type
    
    # Element extentTypeCode ({http://www.isotc211.org/2005/gmd}extentTypeCode) inherited from {http://www.isotc211.org/2005/gmd}AbstractEX_GeographicExtent_Type
    
    # Element {http://www.isotc211.org/2005/gmd}westBoundLongitude uses Python identifier westBoundLongitude
    __westBoundLongitude = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'westBoundLongitude'), 'westBoundLongitude', '__httpwww_isotc211_org2005gmd_EX_GeographicBoundingBox_Type_httpwww_isotc211_org2005gmdwestBoundLongitude', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/extent.xsd', 144, 5), )

    
    westBoundLongitude = property(__westBoundLongitude.value, __westBoundLongitude.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}eastBoundLongitude uses Python identifier eastBoundLongitude
    __eastBoundLongitude = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'eastBoundLongitude'), 'eastBoundLongitude', '__httpwww_isotc211_org2005gmd_EX_GeographicBoundingBox_Type_httpwww_isotc211_org2005gmdeastBoundLongitude', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/extent.xsd', 145, 5), )

    
    eastBoundLongitude = property(__eastBoundLongitude.value, __eastBoundLongitude.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}southBoundLatitude uses Python identifier southBoundLatitude
    __southBoundLatitude = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'southBoundLatitude'), 'southBoundLatitude', '__httpwww_isotc211_org2005gmd_EX_GeographicBoundingBox_Type_httpwww_isotc211_org2005gmdsouthBoundLatitude', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/extent.xsd', 146, 5), )

    
    southBoundLatitude = property(__southBoundLatitude.value, __southBoundLatitude.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}northBoundLatitude uses Python identifier northBoundLatitude
    __northBoundLatitude = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'northBoundLatitude'), 'northBoundLatitude', '__httpwww_isotc211_org2005gmd_EX_GeographicBoundingBox_Type_httpwww_isotc211_org2005gmdnorthBoundLatitude', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/extent.xsd', 147, 5), )

    
    northBoundLatitude = property(__northBoundLatitude.value, __northBoundLatitude.set, None, None)

    
    # Attribute id inherited from {http://www.isotc211.org/2005/gco}AbstractObject_Type
    
    # Attribute uuid inherited from {http://www.isotc211.org/2005/gco}AbstractObject_Type
    _ElementMap.update({
        __westBoundLongitude.name() : __westBoundLongitude,
        __eastBoundLongitude.name() : __eastBoundLongitude,
        __southBoundLatitude.name() : __southBoundLatitude,
        __northBoundLatitude.name() : __northBoundLatitude
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.EX_GeographicBoundingBox_Type = EX_GeographicBoundingBox_Type
_Namespace_gmd.addCategoryObject('typeBinding', 'EX_GeographicBoundingBox_Type', EX_GeographicBoundingBox_Type)


# Complex type {http://www.isotc211.org/2005/gmd}EX_GeographicBoundingBox_PropertyType with content type ELEMENT_ONLY
class EX_GeographicBoundingBox_PropertyType (pyxb.binding.basis.complexTypeDefinition):
    """Complex type {http://www.isotc211.org/2005/gmd}EX_GeographicBoundingBox_PropertyType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'EX_GeographicBoundingBox_PropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/extent.xsd', 155, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.isotc211.org/2005/gmd}EX_GeographicBoundingBox uses Python identifier EX_GeographicBoundingBox
    __EX_GeographicBoundingBox = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'EX_GeographicBoundingBox'), 'EX_GeographicBoundingBox', '__httpwww_isotc211_org2005gmd_EX_GeographicBoundingBox_PropertyType_httpwww_isotc211_org2005gmdEX_GeographicBoundingBox', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/extent.xsd', 153, 1), )

    
    EX_GeographicBoundingBox = property(__EX_GeographicBoundingBox.value, __EX_GeographicBoundingBox.set, None, None)

    
    # Attribute uuidref uses Python identifier uuidref
    __uuidref = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'uuidref'), 'uuidref', '__httpwww_isotc211_org2005gmd_EX_GeographicBoundingBox_PropertyType_uuidref', pyxb.binding.datatypes.string)
    __uuidref._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 30, 2)
    __uuidref._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 30, 2)
    
    uuidref = property(__uuidref.value, __uuidref.set, None, None)

    
    # Attribute {http://www.isotc211.org/2005/gco}nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gco, 'nilReason'), 'nilReason', '__httpwww_isotc211_org2005gmd_EX_GeographicBoundingBox_PropertyType_httpwww_isotc211_org2005gconilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 33, 1)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/extent.xsd', 160, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}type uses Python identifier type
    __type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'type'), 'type', '__httpwww_isotc211_org2005gmd_EX_GeographicBoundingBox_PropertyType_httpwww_w3_org1999xlinktype', _ImportedBinding_bindings_v1411_write__xlink.typeType, fixed=True, unicode_default='simple')
    __type._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 29, 1)
    __type._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 112, 2)
    
    type = property(__type.value, __type.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}href uses Python identifier href
    __href = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'href'), 'href', '__httpwww_isotc211_org2005gmd_EX_GeographicBoundingBox_PropertyType_httpwww_w3_org1999xlinkhref', _ImportedBinding_bindings_v1411_write__xlink.hrefType)
    __href._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 42, 1)
    __href._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 113, 2)
    
    href = property(__href.value, __href.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}role uses Python identifier role
    __role = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'role'), 'role', '__httpwww_isotc211_org2005gmd_EX_GeographicBoundingBox_PropertyType_httpwww_w3_org1999xlinkrole', _ImportedBinding_bindings_v1411_write__xlink.roleType)
    __role._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 48, 1)
    __role._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 114, 2)
    
    role = property(__role.value, __role.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}arcrole uses Python identifier arcrole
    __arcrole = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'arcrole'), 'arcrole', '__httpwww_isotc211_org2005gmd_EX_GeographicBoundingBox_PropertyType_httpwww_w3_org1999xlinkarcrole', _ImportedBinding_bindings_v1411_write__xlink.arcroleType)
    __arcrole._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 56, 1)
    __arcrole._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 115, 2)
    
    arcrole = property(__arcrole.value, __arcrole.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}title uses Python identifier title
    __title = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'title'), 'title', '__httpwww_isotc211_org2005gmd_EX_GeographicBoundingBox_PropertyType_httpwww_w3_org1999xlinktitle', _ImportedBinding_bindings_v1411_write__xlink.titleAttrType)
    __title._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 64, 1)
    __title._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 116, 2)
    
    title = property(__title.value, __title.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}show uses Python identifier show
    __show = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'show'), 'show', '__httpwww_isotc211_org2005gmd_EX_GeographicBoundingBox_PropertyType_httpwww_w3_org1999xlinkshow', _ImportedBinding_bindings_v1411_write__xlink.showType)
    __show._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 70, 1)
    __show._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 117, 2)
    
    show = property(__show.value, __show.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}actuate uses Python identifier actuate
    __actuate = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'actuate'), 'actuate', '__httpwww_isotc211_org2005gmd_EX_GeographicBoundingBox_PropertyType_httpwww_w3_org1999xlinkactuate', _ImportedBinding_bindings_v1411_write__xlink.actuateType)
    __actuate._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 82, 1)
    __actuate._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 118, 2)
    
    actuate = property(__actuate.value, __actuate.set, None, None)

    _ElementMap.update({
        __EX_GeographicBoundingBox.name() : __EX_GeographicBoundingBox
    })
    _AttributeMap.update({
        __uuidref.name() : __uuidref,
        __nilReason.name() : __nilReason,
        __type.name() : __type,
        __href.name() : __href,
        __role.name() : __role,
        __arcrole.name() : __arcrole,
        __title.name() : __title,
        __show.name() : __show,
        __actuate.name() : __actuate
    })
_module_typeBindings.EX_GeographicBoundingBox_PropertyType = EX_GeographicBoundingBox_PropertyType
_Namespace_gmd.addCategoryObject('typeBinding', 'EX_GeographicBoundingBox_PropertyType', EX_GeographicBoundingBox_PropertyType)


# Complex type {http://www.isotc211.org/2005/gmd}EX_SpatialTemporalExtent_Type with content type ELEMENT_ONLY
class EX_SpatialTemporalExtent_Type (EX_TemporalExtent_Type):
    """Extent with respect to date and time"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'EX_SpatialTemporalExtent_Type')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/extent.xsd', 163, 1)
    _ElementMap = EX_TemporalExtent_Type._ElementMap.copy()
    _AttributeMap = EX_TemporalExtent_Type._AttributeMap.copy()
    # Base type is EX_TemporalExtent_Type
    
    # Element extent ({http://www.isotc211.org/2005/gmd}extent) inherited from {http://www.isotc211.org/2005/gmd}EX_TemporalExtent_Type
    
    # Element {http://www.isotc211.org/2005/gmd}spatialExtent uses Python identifier spatialExtent
    __spatialExtent = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'spatialExtent'), 'spatialExtent', '__httpwww_isotc211_org2005gmd_EX_SpatialTemporalExtent_Type_httpwww_isotc211_org2005gmdspatialExtent', True, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/extent.xsd', 170, 5), )

    
    spatialExtent = property(__spatialExtent.value, __spatialExtent.set, None, None)

    
    # Attribute id inherited from {http://www.isotc211.org/2005/gco}AbstractObject_Type
    
    # Attribute uuid inherited from {http://www.isotc211.org/2005/gco}AbstractObject_Type
    _ElementMap.update({
        __spatialExtent.name() : __spatialExtent
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.EX_SpatialTemporalExtent_Type = EX_SpatialTemporalExtent_Type
_Namespace_gmd.addCategoryObject('typeBinding', 'EX_SpatialTemporalExtent_Type', EX_SpatialTemporalExtent_Type)


# Complex type {http://www.isotc211.org/2005/gmd}EX_SpatialTemporalExtent_PropertyType with content type ELEMENT_ONLY
class EX_SpatialTemporalExtent_PropertyType (pyxb.binding.basis.complexTypeDefinition):
    """Complex type {http://www.isotc211.org/2005/gmd}EX_SpatialTemporalExtent_PropertyType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'EX_SpatialTemporalExtent_PropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/extent.xsd', 178, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.isotc211.org/2005/gmd}EX_SpatialTemporalExtent uses Python identifier EX_SpatialTemporalExtent
    __EX_SpatialTemporalExtent = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'EX_SpatialTemporalExtent'), 'EX_SpatialTemporalExtent', '__httpwww_isotc211_org2005gmd_EX_SpatialTemporalExtent_PropertyType_httpwww_isotc211_org2005gmdEX_SpatialTemporalExtent', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/extent.xsd', 176, 1), )

    
    EX_SpatialTemporalExtent = property(__EX_SpatialTemporalExtent.value, __EX_SpatialTemporalExtent.set, None, None)

    
    # Attribute uuidref uses Python identifier uuidref
    __uuidref = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'uuidref'), 'uuidref', '__httpwww_isotc211_org2005gmd_EX_SpatialTemporalExtent_PropertyType_uuidref', pyxb.binding.datatypes.string)
    __uuidref._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 30, 2)
    __uuidref._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 30, 2)
    
    uuidref = property(__uuidref.value, __uuidref.set, None, None)

    
    # Attribute {http://www.isotc211.org/2005/gco}nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gco, 'nilReason'), 'nilReason', '__httpwww_isotc211_org2005gmd_EX_SpatialTemporalExtent_PropertyType_httpwww_isotc211_org2005gconilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 33, 1)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/extent.xsd', 183, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}type uses Python identifier type
    __type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'type'), 'type', '__httpwww_isotc211_org2005gmd_EX_SpatialTemporalExtent_PropertyType_httpwww_w3_org1999xlinktype', _ImportedBinding_bindings_v1411_write__xlink.typeType, fixed=True, unicode_default='simple')
    __type._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 29, 1)
    __type._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 112, 2)
    
    type = property(__type.value, __type.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}href uses Python identifier href
    __href = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'href'), 'href', '__httpwww_isotc211_org2005gmd_EX_SpatialTemporalExtent_PropertyType_httpwww_w3_org1999xlinkhref', _ImportedBinding_bindings_v1411_write__xlink.hrefType)
    __href._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 42, 1)
    __href._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 113, 2)
    
    href = property(__href.value, __href.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}role uses Python identifier role
    __role = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'role'), 'role', '__httpwww_isotc211_org2005gmd_EX_SpatialTemporalExtent_PropertyType_httpwww_w3_org1999xlinkrole', _ImportedBinding_bindings_v1411_write__xlink.roleType)
    __role._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 48, 1)
    __role._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 114, 2)
    
    role = property(__role.value, __role.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}arcrole uses Python identifier arcrole
    __arcrole = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'arcrole'), 'arcrole', '__httpwww_isotc211_org2005gmd_EX_SpatialTemporalExtent_PropertyType_httpwww_w3_org1999xlinkarcrole', _ImportedBinding_bindings_v1411_write__xlink.arcroleType)
    __arcrole._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 56, 1)
    __arcrole._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 115, 2)
    
    arcrole = property(__arcrole.value, __arcrole.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}title uses Python identifier title
    __title = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'title'), 'title', '__httpwww_isotc211_org2005gmd_EX_SpatialTemporalExtent_PropertyType_httpwww_w3_org1999xlinktitle', _ImportedBinding_bindings_v1411_write__xlink.titleAttrType)
    __title._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 64, 1)
    __title._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 116, 2)
    
    title = property(__title.value, __title.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}show uses Python identifier show
    __show = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'show'), 'show', '__httpwww_isotc211_org2005gmd_EX_SpatialTemporalExtent_PropertyType_httpwww_w3_org1999xlinkshow', _ImportedBinding_bindings_v1411_write__xlink.showType)
    __show._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 70, 1)
    __show._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 117, 2)
    
    show = property(__show.value, __show.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}actuate uses Python identifier actuate
    __actuate = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'actuate'), 'actuate', '__httpwww_isotc211_org2005gmd_EX_SpatialTemporalExtent_PropertyType_httpwww_w3_org1999xlinkactuate', _ImportedBinding_bindings_v1411_write__xlink.actuateType)
    __actuate._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 82, 1)
    __actuate._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 118, 2)
    
    actuate = property(__actuate.value, __actuate.set, None, None)

    _ElementMap.update({
        __EX_SpatialTemporalExtent.name() : __EX_SpatialTemporalExtent
    })
    _AttributeMap.update({
        __uuidref.name() : __uuidref,
        __nilReason.name() : __nilReason,
        __type.name() : __type,
        __href.name() : __href,
        __role.name() : __role,
        __arcrole.name() : __arcrole,
        __title.name() : __title,
        __show.name() : __show,
        __actuate.name() : __actuate
    })
_module_typeBindings.EX_SpatialTemporalExtent_PropertyType = EX_SpatialTemporalExtent_PropertyType
_Namespace_gmd.addCategoryObject('typeBinding', 'EX_SpatialTemporalExtent_PropertyType', EX_SpatialTemporalExtent_PropertyType)


# Complex type {http://www.isotc211.org/2005/gmd}EX_GeographicDescription_Type with content type ELEMENT_ONLY
class EX_GeographicDescription_Type (AbstractEX_GeographicExtent_Type):
    """Complex type {http://www.isotc211.org/2005/gmd}EX_GeographicDescription_Type with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'EX_GeographicDescription_Type')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/extent.xsd', 186, 1)
    _ElementMap = AbstractEX_GeographicExtent_Type._ElementMap.copy()
    _AttributeMap = AbstractEX_GeographicExtent_Type._AttributeMap.copy()
    # Base type is AbstractEX_GeographicExtent_Type
    
    # Element extentTypeCode ({http://www.isotc211.org/2005/gmd}extentTypeCode) inherited from {http://www.isotc211.org/2005/gmd}AbstractEX_GeographicExtent_Type
    
    # Element {http://www.isotc211.org/2005/gmd}geographicIdentifier uses Python identifier geographicIdentifier
    __geographicIdentifier = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'geographicIdentifier'), 'geographicIdentifier', '__httpwww_isotc211_org2005gmd_EX_GeographicDescription_Type_httpwww_isotc211_org2005gmdgeographicIdentifier', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/extent.xsd', 190, 5), )

    
    geographicIdentifier = property(__geographicIdentifier.value, __geographicIdentifier.set, None, None)

    
    # Attribute id inherited from {http://www.isotc211.org/2005/gco}AbstractObject_Type
    
    # Attribute uuid inherited from {http://www.isotc211.org/2005/gco}AbstractObject_Type
    _ElementMap.update({
        __geographicIdentifier.name() : __geographicIdentifier
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.EX_GeographicDescription_Type = EX_GeographicDescription_Type
_Namespace_gmd.addCategoryObject('typeBinding', 'EX_GeographicDescription_Type', EX_GeographicDescription_Type)


# Complex type {http://www.isotc211.org/2005/gmd}EX_GeographicDescription_PropertyType with content type ELEMENT_ONLY
class EX_GeographicDescription_PropertyType (pyxb.binding.basis.complexTypeDefinition):
    """Complex type {http://www.isotc211.org/2005/gmd}EX_GeographicDescription_PropertyType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'EX_GeographicDescription_PropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/extent.xsd', 198, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.isotc211.org/2005/gmd}EX_GeographicDescription uses Python identifier EX_GeographicDescription
    __EX_GeographicDescription = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'EX_GeographicDescription'), 'EX_GeographicDescription', '__httpwww_isotc211_org2005gmd_EX_GeographicDescription_PropertyType_httpwww_isotc211_org2005gmdEX_GeographicDescription', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/extent.xsd', 196, 1), )

    
    EX_GeographicDescription = property(__EX_GeographicDescription.value, __EX_GeographicDescription.set, None, None)

    
    # Attribute uuidref uses Python identifier uuidref
    __uuidref = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'uuidref'), 'uuidref', '__httpwww_isotc211_org2005gmd_EX_GeographicDescription_PropertyType_uuidref', pyxb.binding.datatypes.string)
    __uuidref._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 30, 2)
    __uuidref._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 30, 2)
    
    uuidref = property(__uuidref.value, __uuidref.set, None, None)

    
    # Attribute {http://www.isotc211.org/2005/gco}nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gco, 'nilReason'), 'nilReason', '__httpwww_isotc211_org2005gmd_EX_GeographicDescription_PropertyType_httpwww_isotc211_org2005gconilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 33, 1)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/extent.xsd', 203, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}type uses Python identifier type
    __type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'type'), 'type', '__httpwww_isotc211_org2005gmd_EX_GeographicDescription_PropertyType_httpwww_w3_org1999xlinktype', _ImportedBinding_bindings_v1411_write__xlink.typeType, fixed=True, unicode_default='simple')
    __type._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 29, 1)
    __type._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 112, 2)
    
    type = property(__type.value, __type.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}href uses Python identifier href
    __href = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'href'), 'href', '__httpwww_isotc211_org2005gmd_EX_GeographicDescription_PropertyType_httpwww_w3_org1999xlinkhref', _ImportedBinding_bindings_v1411_write__xlink.hrefType)
    __href._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 42, 1)
    __href._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 113, 2)
    
    href = property(__href.value, __href.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}role uses Python identifier role
    __role = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'role'), 'role', '__httpwww_isotc211_org2005gmd_EX_GeographicDescription_PropertyType_httpwww_w3_org1999xlinkrole', _ImportedBinding_bindings_v1411_write__xlink.roleType)
    __role._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 48, 1)
    __role._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 114, 2)
    
    role = property(__role.value, __role.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}arcrole uses Python identifier arcrole
    __arcrole = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'arcrole'), 'arcrole', '__httpwww_isotc211_org2005gmd_EX_GeographicDescription_PropertyType_httpwww_w3_org1999xlinkarcrole', _ImportedBinding_bindings_v1411_write__xlink.arcroleType)
    __arcrole._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 56, 1)
    __arcrole._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 115, 2)
    
    arcrole = property(__arcrole.value, __arcrole.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}title uses Python identifier title
    __title = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'title'), 'title', '__httpwww_isotc211_org2005gmd_EX_GeographicDescription_PropertyType_httpwww_w3_org1999xlinktitle', _ImportedBinding_bindings_v1411_write__xlink.titleAttrType)
    __title._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 64, 1)
    __title._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 116, 2)
    
    title = property(__title.value, __title.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}show uses Python identifier show
    __show = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'show'), 'show', '__httpwww_isotc211_org2005gmd_EX_GeographicDescription_PropertyType_httpwww_w3_org1999xlinkshow', _ImportedBinding_bindings_v1411_write__xlink.showType)
    __show._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 70, 1)
    __show._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 117, 2)
    
    show = property(__show.value, __show.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}actuate uses Python identifier actuate
    __actuate = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'actuate'), 'actuate', '__httpwww_isotc211_org2005gmd_EX_GeographicDescription_PropertyType_httpwww_w3_org1999xlinkactuate', _ImportedBinding_bindings_v1411_write__xlink.actuateType)
    __actuate._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 82, 1)
    __actuate._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 118, 2)
    
    actuate = property(__actuate.value, __actuate.set, None, None)

    _ElementMap.update({
        __EX_GeographicDescription.name() : __EX_GeographicDescription
    })
    _AttributeMap.update({
        __uuidref.name() : __uuidref,
        __nilReason.name() : __nilReason,
        __type.name() : __type,
        __href.name() : __href,
        __role.name() : __role,
        __arcrole.name() : __arcrole,
        __title.name() : __title,
        __show.name() : __show,
        __actuate.name() : __actuate
    })
_module_typeBindings.EX_GeographicDescription_PropertyType = EX_GeographicDescription_PropertyType
_Namespace_gmd.addCategoryObject('typeBinding', 'EX_GeographicDescription_PropertyType', EX_GeographicDescription_PropertyType)


# Complex type {http://www.isotc211.org/2005/gmd}PT_Locale_PropertyType with content type ELEMENT_ONLY
class PT_Locale_PropertyType (pyxb.binding.basis.complexTypeDefinition):
    """Complex type {http://www.isotc211.org/2005/gmd}PT_Locale_PropertyType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'PT_Locale_PropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/freeText.xsd', 50, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.isotc211.org/2005/gmd}PT_Locale uses Python identifier PT_Locale
    __PT_Locale = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'PT_Locale'), 'PT_Locale', '__httpwww_isotc211_org2005gmd_PT_Locale_PropertyType_httpwww_isotc211_org2005gmdPT_Locale', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/freeText.xsd', 48, 1), )

    
    PT_Locale = property(__PT_Locale.value, __PT_Locale.set, None, None)

    
    # Attribute uuidref uses Python identifier uuidref
    __uuidref = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'uuidref'), 'uuidref', '__httpwww_isotc211_org2005gmd_PT_Locale_PropertyType_uuidref', pyxb.binding.datatypes.string)
    __uuidref._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 30, 2)
    __uuidref._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 30, 2)
    
    uuidref = property(__uuidref.value, __uuidref.set, None, None)

    
    # Attribute {http://www.isotc211.org/2005/gco}nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gco, 'nilReason'), 'nilReason', '__httpwww_isotc211_org2005gmd_PT_Locale_PropertyType_httpwww_isotc211_org2005gconilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 33, 1)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/freeText.xsd', 55, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}type uses Python identifier type
    __type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'type'), 'type', '__httpwww_isotc211_org2005gmd_PT_Locale_PropertyType_httpwww_w3_org1999xlinktype', _ImportedBinding_bindings_v1411_write__xlink.typeType, fixed=True, unicode_default='simple')
    __type._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 29, 1)
    __type._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 112, 2)
    
    type = property(__type.value, __type.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}href uses Python identifier href
    __href = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'href'), 'href', '__httpwww_isotc211_org2005gmd_PT_Locale_PropertyType_httpwww_w3_org1999xlinkhref', _ImportedBinding_bindings_v1411_write__xlink.hrefType)
    __href._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 42, 1)
    __href._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 113, 2)
    
    href = property(__href.value, __href.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}role uses Python identifier role
    __role = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'role'), 'role', '__httpwww_isotc211_org2005gmd_PT_Locale_PropertyType_httpwww_w3_org1999xlinkrole', _ImportedBinding_bindings_v1411_write__xlink.roleType)
    __role._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 48, 1)
    __role._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 114, 2)
    
    role = property(__role.value, __role.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}arcrole uses Python identifier arcrole
    __arcrole = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'arcrole'), 'arcrole', '__httpwww_isotc211_org2005gmd_PT_Locale_PropertyType_httpwww_w3_org1999xlinkarcrole', _ImportedBinding_bindings_v1411_write__xlink.arcroleType)
    __arcrole._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 56, 1)
    __arcrole._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 115, 2)
    
    arcrole = property(__arcrole.value, __arcrole.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}title uses Python identifier title
    __title = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'title'), 'title', '__httpwww_isotc211_org2005gmd_PT_Locale_PropertyType_httpwww_w3_org1999xlinktitle', _ImportedBinding_bindings_v1411_write__xlink.titleAttrType)
    __title._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 64, 1)
    __title._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 116, 2)
    
    title = property(__title.value, __title.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}show uses Python identifier show
    __show = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'show'), 'show', '__httpwww_isotc211_org2005gmd_PT_Locale_PropertyType_httpwww_w3_org1999xlinkshow', _ImportedBinding_bindings_v1411_write__xlink.showType)
    __show._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 70, 1)
    __show._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 117, 2)
    
    show = property(__show.value, __show.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}actuate uses Python identifier actuate
    __actuate = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'actuate'), 'actuate', '__httpwww_isotc211_org2005gmd_PT_Locale_PropertyType_httpwww_w3_org1999xlinkactuate', _ImportedBinding_bindings_v1411_write__xlink.actuateType)
    __actuate._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 82, 1)
    __actuate._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 118, 2)
    
    actuate = property(__actuate.value, __actuate.set, None, None)

    _ElementMap.update({
        __PT_Locale.name() : __PT_Locale
    })
    _AttributeMap.update({
        __uuidref.name() : __uuidref,
        __nilReason.name() : __nilReason,
        __type.name() : __type,
        __href.name() : __href,
        __role.name() : __role,
        __arcrole.name() : __arcrole,
        __title.name() : __title,
        __show.name() : __show,
        __actuate.name() : __actuate
    })
_module_typeBindings.PT_Locale_PropertyType = PT_Locale_PropertyType
_Namespace_gmd.addCategoryObject('typeBinding', 'PT_Locale_PropertyType', PT_Locale_PropertyType)


# Complex type {http://www.isotc211.org/2005/gmd}PT_LocaleContainer_PropertyType with content type ELEMENT_ONLY
class PT_LocaleContainer_PropertyType (pyxb.binding.basis.complexTypeDefinition):
    """Complex type {http://www.isotc211.org/2005/gmd}PT_LocaleContainer_PropertyType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'PT_LocaleContainer_PropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/freeText.xsd', 91, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.isotc211.org/2005/gmd}PT_LocaleContainer uses Python identifier PT_LocaleContainer
    __PT_LocaleContainer = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'PT_LocaleContainer'), 'PT_LocaleContainer', '__httpwww_isotc211_org2005gmd_PT_LocaleContainer_PropertyType_httpwww_isotc211_org2005gmdPT_LocaleContainer', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/freeText.xsd', 89, 1), )

    
    PT_LocaleContainer = property(__PT_LocaleContainer.value, __PT_LocaleContainer.set, None, None)

    
    # Attribute uuidref uses Python identifier uuidref
    __uuidref = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'uuidref'), 'uuidref', '__httpwww_isotc211_org2005gmd_PT_LocaleContainer_PropertyType_uuidref', pyxb.binding.datatypes.string)
    __uuidref._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 30, 2)
    __uuidref._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 30, 2)
    
    uuidref = property(__uuidref.value, __uuidref.set, None, None)

    
    # Attribute {http://www.isotc211.org/2005/gco}nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gco, 'nilReason'), 'nilReason', '__httpwww_isotc211_org2005gmd_PT_LocaleContainer_PropertyType_httpwww_isotc211_org2005gconilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 33, 1)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/freeText.xsd', 96, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}type uses Python identifier type
    __type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'type'), 'type', '__httpwww_isotc211_org2005gmd_PT_LocaleContainer_PropertyType_httpwww_w3_org1999xlinktype', _ImportedBinding_bindings_v1411_write__xlink.typeType, fixed=True, unicode_default='simple')
    __type._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 29, 1)
    __type._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 112, 2)
    
    type = property(__type.value, __type.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}href uses Python identifier href
    __href = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'href'), 'href', '__httpwww_isotc211_org2005gmd_PT_LocaleContainer_PropertyType_httpwww_w3_org1999xlinkhref', _ImportedBinding_bindings_v1411_write__xlink.hrefType)
    __href._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 42, 1)
    __href._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 113, 2)
    
    href = property(__href.value, __href.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}role uses Python identifier role
    __role = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'role'), 'role', '__httpwww_isotc211_org2005gmd_PT_LocaleContainer_PropertyType_httpwww_w3_org1999xlinkrole', _ImportedBinding_bindings_v1411_write__xlink.roleType)
    __role._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 48, 1)
    __role._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 114, 2)
    
    role = property(__role.value, __role.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}arcrole uses Python identifier arcrole
    __arcrole = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'arcrole'), 'arcrole', '__httpwww_isotc211_org2005gmd_PT_LocaleContainer_PropertyType_httpwww_w3_org1999xlinkarcrole', _ImportedBinding_bindings_v1411_write__xlink.arcroleType)
    __arcrole._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 56, 1)
    __arcrole._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 115, 2)
    
    arcrole = property(__arcrole.value, __arcrole.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}title uses Python identifier title
    __title = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'title'), 'title', '__httpwww_isotc211_org2005gmd_PT_LocaleContainer_PropertyType_httpwww_w3_org1999xlinktitle', _ImportedBinding_bindings_v1411_write__xlink.titleAttrType)
    __title._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 64, 1)
    __title._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 116, 2)
    
    title = property(__title.value, __title.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}show uses Python identifier show
    __show = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'show'), 'show', '__httpwww_isotc211_org2005gmd_PT_LocaleContainer_PropertyType_httpwww_w3_org1999xlinkshow', _ImportedBinding_bindings_v1411_write__xlink.showType)
    __show._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 70, 1)
    __show._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 117, 2)
    
    show = property(__show.value, __show.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}actuate uses Python identifier actuate
    __actuate = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'actuate'), 'actuate', '__httpwww_isotc211_org2005gmd_PT_LocaleContainer_PropertyType_httpwww_w3_org1999xlinkactuate', _ImportedBinding_bindings_v1411_write__xlink.actuateType)
    __actuate._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 82, 1)
    __actuate._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 118, 2)
    
    actuate = property(__actuate.value, __actuate.set, None, None)

    _ElementMap.update({
        __PT_LocaleContainer.name() : __PT_LocaleContainer
    })
    _AttributeMap.update({
        __uuidref.name() : __uuidref,
        __nilReason.name() : __nilReason,
        __type.name() : __type,
        __href.name() : __href,
        __role.name() : __role,
        __arcrole.name() : __arcrole,
        __title.name() : __title,
        __show.name() : __show,
        __actuate.name() : __actuate
    })
_module_typeBindings.PT_LocaleContainer_PropertyType = PT_LocaleContainer_PropertyType
_Namespace_gmd.addCategoryObject('typeBinding', 'PT_LocaleContainer_PropertyType', PT_LocaleContainer_PropertyType)


# Complex type {http://www.isotc211.org/2005/gmd}LanguageCode_PropertyType with content type ELEMENT_ONLY
class LanguageCode_PropertyType (pyxb.binding.basis.complexTypeDefinition):
    """Complex type {http://www.isotc211.org/2005/gmd}LanguageCode_PropertyType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'LanguageCode_PropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/freeText.xsd', 105, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.isotc211.org/2005/gmd}LanguageCode uses Python identifier LanguageCode
    __LanguageCode = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'LanguageCode'), 'LanguageCode', '__httpwww_isotc211_org2005gmd_LanguageCode_PropertyType_httpwww_isotc211_org2005gmdLanguageCode', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/freeText.xsd', 103, 1), )

    
    LanguageCode = property(__LanguageCode.value, __LanguageCode.set, None, None)

    
    # Attribute {http://www.isotc211.org/2005/gco}nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gco, 'nilReason'), 'nilReason', '__httpwww_isotc211_org2005gmd_LanguageCode_PropertyType_httpwww_isotc211_org2005gconilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 33, 1)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/freeText.xsd', 109, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    _ElementMap.update({
        __LanguageCode.name() : __LanguageCode
    })
    _AttributeMap.update({
        __nilReason.name() : __nilReason
    })
_module_typeBindings.LanguageCode_PropertyType = LanguageCode_PropertyType
_Namespace_gmd.addCategoryObject('typeBinding', 'LanguageCode_PropertyType', LanguageCode_PropertyType)


# Complex type {http://www.isotc211.org/2005/gmd}Country_PropertyType with content type ELEMENT_ONLY
class Country_PropertyType (pyxb.binding.basis.complexTypeDefinition):
    """Complex type {http://www.isotc211.org/2005/gmd}Country_PropertyType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'Country_PropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/freeText.xsd', 115, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.isotc211.org/2005/gmd}Country uses Python identifier Country
    __Country = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'Country'), 'Country', '__httpwww_isotc211_org2005gmd_Country_PropertyType_httpwww_isotc211_org2005gmdCountry', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/freeText.xsd', 113, 1), )

    
    Country = property(__Country.value, __Country.set, None, None)

    
    # Attribute {http://www.isotc211.org/2005/gco}nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gco, 'nilReason'), 'nilReason', '__httpwww_isotc211_org2005gmd_Country_PropertyType_httpwww_isotc211_org2005gconilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 33, 1)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/freeText.xsd', 119, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    _ElementMap.update({
        __Country.name() : __Country
    })
    _AttributeMap.update({
        __nilReason.name() : __nilReason
    })
_module_typeBindings.Country_PropertyType = Country_PropertyType
_Namespace_gmd.addCategoryObject('typeBinding', 'Country_PropertyType', Country_PropertyType)


# Complex type {http://www.isotc211.org/2005/gmd}MD_Identification_PropertyType with content type ELEMENT_ONLY
class MD_Identification_PropertyType (pyxb.binding.basis.complexTypeDefinition):
    """Complex type {http://www.isotc211.org/2005/gmd}MD_Identification_PropertyType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_Identification_PropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 43, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.isotc211.org/2005/gmd}AbstractMD_Identification uses Python identifier AbstractMD_Identification
    __AbstractMD_Identification = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'AbstractMD_Identification'), 'AbstractMD_Identification', '__httpwww_isotc211_org2005gmd_MD_Identification_PropertyType_httpwww_isotc211_org2005gmdAbstractMD_Identification', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 41, 1), )

    
    AbstractMD_Identification = property(__AbstractMD_Identification.value, __AbstractMD_Identification.set, None, None)

    
    # Attribute uuidref uses Python identifier uuidref
    __uuidref = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'uuidref'), 'uuidref', '__httpwww_isotc211_org2005gmd_MD_Identification_PropertyType_uuidref', pyxb.binding.datatypes.string)
    __uuidref._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 30, 2)
    __uuidref._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 30, 2)
    
    uuidref = property(__uuidref.value, __uuidref.set, None, None)

    
    # Attribute {http://www.isotc211.org/2005/gco}nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gco, 'nilReason'), 'nilReason', '__httpwww_isotc211_org2005gmd_MD_Identification_PropertyType_httpwww_isotc211_org2005gconilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 33, 1)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 48, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}type uses Python identifier type
    __type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'type'), 'type', '__httpwww_isotc211_org2005gmd_MD_Identification_PropertyType_httpwww_w3_org1999xlinktype', _ImportedBinding_bindings_v1411_write__xlink.typeType, fixed=True, unicode_default='simple')
    __type._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 29, 1)
    __type._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 112, 2)
    
    type = property(__type.value, __type.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}href uses Python identifier href
    __href = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'href'), 'href', '__httpwww_isotc211_org2005gmd_MD_Identification_PropertyType_httpwww_w3_org1999xlinkhref', _ImportedBinding_bindings_v1411_write__xlink.hrefType)
    __href._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 42, 1)
    __href._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 113, 2)
    
    href = property(__href.value, __href.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}role uses Python identifier role
    __role = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'role'), 'role', '__httpwww_isotc211_org2005gmd_MD_Identification_PropertyType_httpwww_w3_org1999xlinkrole', _ImportedBinding_bindings_v1411_write__xlink.roleType)
    __role._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 48, 1)
    __role._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 114, 2)
    
    role = property(__role.value, __role.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}arcrole uses Python identifier arcrole
    __arcrole = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'arcrole'), 'arcrole', '__httpwww_isotc211_org2005gmd_MD_Identification_PropertyType_httpwww_w3_org1999xlinkarcrole', _ImportedBinding_bindings_v1411_write__xlink.arcroleType)
    __arcrole._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 56, 1)
    __arcrole._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 115, 2)
    
    arcrole = property(__arcrole.value, __arcrole.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}title uses Python identifier title
    __title = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'title'), 'title', '__httpwww_isotc211_org2005gmd_MD_Identification_PropertyType_httpwww_w3_org1999xlinktitle', _ImportedBinding_bindings_v1411_write__xlink.titleAttrType)
    __title._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 64, 1)
    __title._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 116, 2)
    
    title = property(__title.value, __title.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}show uses Python identifier show
    __show = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'show'), 'show', '__httpwww_isotc211_org2005gmd_MD_Identification_PropertyType_httpwww_w3_org1999xlinkshow', _ImportedBinding_bindings_v1411_write__xlink.showType)
    __show._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 70, 1)
    __show._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 117, 2)
    
    show = property(__show.value, __show.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}actuate uses Python identifier actuate
    __actuate = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'actuate'), 'actuate', '__httpwww_isotc211_org2005gmd_MD_Identification_PropertyType_httpwww_w3_org1999xlinkactuate', _ImportedBinding_bindings_v1411_write__xlink.actuateType)
    __actuate._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 82, 1)
    __actuate._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 118, 2)
    
    actuate = property(__actuate.value, __actuate.set, None, None)

    _ElementMap.update({
        __AbstractMD_Identification.name() : __AbstractMD_Identification
    })
    _AttributeMap.update({
        __uuidref.name() : __uuidref,
        __nilReason.name() : __nilReason,
        __type.name() : __type,
        __href.name() : __href,
        __role.name() : __role,
        __arcrole.name() : __arcrole,
        __title.name() : __title,
        __show.name() : __show,
        __actuate.name() : __actuate
    })
_module_typeBindings.MD_Identification_PropertyType = MD_Identification_PropertyType
_Namespace_gmd.addCategoryObject('typeBinding', 'MD_Identification_PropertyType', MD_Identification_PropertyType)


# Complex type {http://www.isotc211.org/2005/gmd}MD_BrowseGraphic_PropertyType with content type ELEMENT_ONLY
class MD_BrowseGraphic_PropertyType (pyxb.binding.basis.complexTypeDefinition):
    """Complex type {http://www.isotc211.org/2005/gmd}MD_BrowseGraphic_PropertyType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_BrowseGraphic_PropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 68, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.isotc211.org/2005/gmd}MD_BrowseGraphic uses Python identifier MD_BrowseGraphic
    __MD_BrowseGraphic = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_BrowseGraphic'), 'MD_BrowseGraphic', '__httpwww_isotc211_org2005gmd_MD_BrowseGraphic_PropertyType_httpwww_isotc211_org2005gmdMD_BrowseGraphic', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 66, 1), )

    
    MD_BrowseGraphic = property(__MD_BrowseGraphic.value, __MD_BrowseGraphic.set, None, None)

    
    # Attribute uuidref uses Python identifier uuidref
    __uuidref = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'uuidref'), 'uuidref', '__httpwww_isotc211_org2005gmd_MD_BrowseGraphic_PropertyType_uuidref', pyxb.binding.datatypes.string)
    __uuidref._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 30, 2)
    __uuidref._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 30, 2)
    
    uuidref = property(__uuidref.value, __uuidref.set, None, None)

    
    # Attribute {http://www.isotc211.org/2005/gco}nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gco, 'nilReason'), 'nilReason', '__httpwww_isotc211_org2005gmd_MD_BrowseGraphic_PropertyType_httpwww_isotc211_org2005gconilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 33, 1)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 73, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}type uses Python identifier type
    __type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'type'), 'type', '__httpwww_isotc211_org2005gmd_MD_BrowseGraphic_PropertyType_httpwww_w3_org1999xlinktype', _ImportedBinding_bindings_v1411_write__xlink.typeType, fixed=True, unicode_default='simple')
    __type._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 29, 1)
    __type._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 112, 2)
    
    type = property(__type.value, __type.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}href uses Python identifier href
    __href = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'href'), 'href', '__httpwww_isotc211_org2005gmd_MD_BrowseGraphic_PropertyType_httpwww_w3_org1999xlinkhref', _ImportedBinding_bindings_v1411_write__xlink.hrefType)
    __href._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 42, 1)
    __href._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 113, 2)
    
    href = property(__href.value, __href.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}role uses Python identifier role
    __role = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'role'), 'role', '__httpwww_isotc211_org2005gmd_MD_BrowseGraphic_PropertyType_httpwww_w3_org1999xlinkrole', _ImportedBinding_bindings_v1411_write__xlink.roleType)
    __role._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 48, 1)
    __role._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 114, 2)
    
    role = property(__role.value, __role.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}arcrole uses Python identifier arcrole
    __arcrole = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'arcrole'), 'arcrole', '__httpwww_isotc211_org2005gmd_MD_BrowseGraphic_PropertyType_httpwww_w3_org1999xlinkarcrole', _ImportedBinding_bindings_v1411_write__xlink.arcroleType)
    __arcrole._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 56, 1)
    __arcrole._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 115, 2)
    
    arcrole = property(__arcrole.value, __arcrole.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}title uses Python identifier title
    __title = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'title'), 'title', '__httpwww_isotc211_org2005gmd_MD_BrowseGraphic_PropertyType_httpwww_w3_org1999xlinktitle', _ImportedBinding_bindings_v1411_write__xlink.titleAttrType)
    __title._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 64, 1)
    __title._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 116, 2)
    
    title = property(__title.value, __title.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}show uses Python identifier show
    __show = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'show'), 'show', '__httpwww_isotc211_org2005gmd_MD_BrowseGraphic_PropertyType_httpwww_w3_org1999xlinkshow', _ImportedBinding_bindings_v1411_write__xlink.showType)
    __show._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 70, 1)
    __show._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 117, 2)
    
    show = property(__show.value, __show.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}actuate uses Python identifier actuate
    __actuate = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'actuate'), 'actuate', '__httpwww_isotc211_org2005gmd_MD_BrowseGraphic_PropertyType_httpwww_w3_org1999xlinkactuate', _ImportedBinding_bindings_v1411_write__xlink.actuateType)
    __actuate._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 82, 1)
    __actuate._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 118, 2)
    
    actuate = property(__actuate.value, __actuate.set, None, None)

    _ElementMap.update({
        __MD_BrowseGraphic.name() : __MD_BrowseGraphic
    })
    _AttributeMap.update({
        __uuidref.name() : __uuidref,
        __nilReason.name() : __nilReason,
        __type.name() : __type,
        __href.name() : __href,
        __role.name() : __role,
        __arcrole.name() : __arcrole,
        __title.name() : __title,
        __show.name() : __show,
        __actuate.name() : __actuate
    })
_module_typeBindings.MD_BrowseGraphic_PropertyType = MD_BrowseGraphic_PropertyType
_Namespace_gmd.addCategoryObject('typeBinding', 'MD_BrowseGraphic_PropertyType', MD_BrowseGraphic_PropertyType)


# Complex type {http://www.isotc211.org/2005/gmd}MD_DataIdentification_Type with content type ELEMENT_ONLY
class MD_DataIdentification_Type (AbstractMD_Identification_Type):
    """Complex type {http://www.isotc211.org/2005/gmd}MD_DataIdentification_Type with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_DataIdentification_Type')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 76, 1)
    _ElementMap = AbstractMD_Identification_Type._ElementMap.copy()
    _AttributeMap = AbstractMD_Identification_Type._AttributeMap.copy()
    # Base type is AbstractMD_Identification_Type
    
    # Element citation ({http://www.isotc211.org/2005/gmd}citation) inherited from {http://www.isotc211.org/2005/gmd}AbstractMD_Identification_Type
    
    # Element abstract ({http://www.isotc211.org/2005/gmd}abstract) inherited from {http://www.isotc211.org/2005/gmd}AbstractMD_Identification_Type
    
    # Element purpose ({http://www.isotc211.org/2005/gmd}purpose) inherited from {http://www.isotc211.org/2005/gmd}AbstractMD_Identification_Type
    
    # Element credit ({http://www.isotc211.org/2005/gmd}credit) inherited from {http://www.isotc211.org/2005/gmd}AbstractMD_Identification_Type
    
    # Element status ({http://www.isotc211.org/2005/gmd}status) inherited from {http://www.isotc211.org/2005/gmd}AbstractMD_Identification_Type
    
    # Element pointOfContact ({http://www.isotc211.org/2005/gmd}pointOfContact) inherited from {http://www.isotc211.org/2005/gmd}AbstractMD_Identification_Type
    
    # Element resourceMaintenance ({http://www.isotc211.org/2005/gmd}resourceMaintenance) inherited from {http://www.isotc211.org/2005/gmd}AbstractMD_Identification_Type
    
    # Element graphicOverview ({http://www.isotc211.org/2005/gmd}graphicOverview) inherited from {http://www.isotc211.org/2005/gmd}AbstractMD_Identification_Type
    
    # Element resourceFormat ({http://www.isotc211.org/2005/gmd}resourceFormat) inherited from {http://www.isotc211.org/2005/gmd}AbstractMD_Identification_Type
    
    # Element descriptiveKeywords ({http://www.isotc211.org/2005/gmd}descriptiveKeywords) inherited from {http://www.isotc211.org/2005/gmd}AbstractMD_Identification_Type
    
    # Element resourceSpecificUsage ({http://www.isotc211.org/2005/gmd}resourceSpecificUsage) inherited from {http://www.isotc211.org/2005/gmd}AbstractMD_Identification_Type
    
    # Element resourceConstraints ({http://www.isotc211.org/2005/gmd}resourceConstraints) inherited from {http://www.isotc211.org/2005/gmd}AbstractMD_Identification_Type
    
    # Element aggregationInfo ({http://www.isotc211.org/2005/gmd}aggregationInfo) inherited from {http://www.isotc211.org/2005/gmd}AbstractMD_Identification_Type
    
    # Element {http://www.isotc211.org/2005/gmd}spatialRepresentationType uses Python identifier spatialRepresentationType
    __spatialRepresentationType = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'spatialRepresentationType'), 'spatialRepresentationType', '__httpwww_isotc211_org2005gmd_MD_DataIdentification_Type_httpwww_isotc211_org2005gmdspatialRepresentationType', True, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 80, 5), )

    
    spatialRepresentationType = property(__spatialRepresentationType.value, __spatialRepresentationType.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}spatialResolution uses Python identifier spatialResolution
    __spatialResolution = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'spatialResolution'), 'spatialResolution', '__httpwww_isotc211_org2005gmd_MD_DataIdentification_Type_httpwww_isotc211_org2005gmdspatialResolution', True, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 81, 5), )

    
    spatialResolution = property(__spatialResolution.value, __spatialResolution.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}language uses Python identifier language
    __language = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'language'), 'language', '__httpwww_isotc211_org2005gmd_MD_DataIdentification_Type_httpwww_isotc211_org2005gmdlanguage', True, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 82, 5), )

    
    language = property(__language.value, __language.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}characterSet uses Python identifier characterSet
    __characterSet = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'characterSet'), 'characterSet', '__httpwww_isotc211_org2005gmd_MD_DataIdentification_Type_httpwww_isotc211_org2005gmdcharacterSet', True, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 83, 5), )

    
    characterSet = property(__characterSet.value, __characterSet.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}topicCategory uses Python identifier topicCategory
    __topicCategory = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'topicCategory'), 'topicCategory', '__httpwww_isotc211_org2005gmd_MD_DataIdentification_Type_httpwww_isotc211_org2005gmdtopicCategory', True, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 84, 5), )

    
    topicCategory = property(__topicCategory.value, __topicCategory.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}environmentDescription uses Python identifier environmentDescription
    __environmentDescription = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'environmentDescription'), 'environmentDescription', '__httpwww_isotc211_org2005gmd_MD_DataIdentification_Type_httpwww_isotc211_org2005gmdenvironmentDescription', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 85, 5), )

    
    environmentDescription = property(__environmentDescription.value, __environmentDescription.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}extent uses Python identifier extent
    __extent = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'extent'), 'extent', '__httpwww_isotc211_org2005gmd_MD_DataIdentification_Type_httpwww_isotc211_org2005gmdextent', True, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 86, 5), )

    
    extent = property(__extent.value, __extent.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}supplementalInformation uses Python identifier supplementalInformation
    __supplementalInformation = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'supplementalInformation'), 'supplementalInformation', '__httpwww_isotc211_org2005gmd_MD_DataIdentification_Type_httpwww_isotc211_org2005gmdsupplementalInformation', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 87, 5), )

    
    supplementalInformation = property(__supplementalInformation.value, __supplementalInformation.set, None, None)

    
    # Attribute id inherited from {http://www.isotc211.org/2005/gco}AbstractObject_Type
    
    # Attribute uuid inherited from {http://www.isotc211.org/2005/gco}AbstractObject_Type
    _ElementMap.update({
        __spatialRepresentationType.name() : __spatialRepresentationType,
        __spatialResolution.name() : __spatialResolution,
        __language.name() : __language,
        __characterSet.name() : __characterSet,
        __topicCategory.name() : __topicCategory,
        __environmentDescription.name() : __environmentDescription,
        __extent.name() : __extent,
        __supplementalInformation.name() : __supplementalInformation
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.MD_DataIdentification_Type = MD_DataIdentification_Type
_Namespace_gmd.addCategoryObject('typeBinding', 'MD_DataIdentification_Type', MD_DataIdentification_Type)


# Complex type {http://www.isotc211.org/2005/gmd}MD_DataIdentification_PropertyType with content type ELEMENT_ONLY
class MD_DataIdentification_PropertyType (pyxb.binding.basis.complexTypeDefinition):
    """Complex type {http://www.isotc211.org/2005/gmd}MD_DataIdentification_PropertyType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_DataIdentification_PropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 95, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.isotc211.org/2005/gmd}MD_DataIdentification uses Python identifier MD_DataIdentification
    __MD_DataIdentification = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_DataIdentification'), 'MD_DataIdentification', '__httpwww_isotc211_org2005gmd_MD_DataIdentification_PropertyType_httpwww_isotc211_org2005gmdMD_DataIdentification', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 93, 1), )

    
    MD_DataIdentification = property(__MD_DataIdentification.value, __MD_DataIdentification.set, None, None)

    
    # Attribute uuidref uses Python identifier uuidref
    __uuidref = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'uuidref'), 'uuidref', '__httpwww_isotc211_org2005gmd_MD_DataIdentification_PropertyType_uuidref', pyxb.binding.datatypes.string)
    __uuidref._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 30, 2)
    __uuidref._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 30, 2)
    
    uuidref = property(__uuidref.value, __uuidref.set, None, None)

    
    # Attribute {http://www.isotc211.org/2005/gco}nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gco, 'nilReason'), 'nilReason', '__httpwww_isotc211_org2005gmd_MD_DataIdentification_PropertyType_httpwww_isotc211_org2005gconilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 33, 1)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 100, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}type uses Python identifier type
    __type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'type'), 'type', '__httpwww_isotc211_org2005gmd_MD_DataIdentification_PropertyType_httpwww_w3_org1999xlinktype', _ImportedBinding_bindings_v1411_write__xlink.typeType, fixed=True, unicode_default='simple')
    __type._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 29, 1)
    __type._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 112, 2)
    
    type = property(__type.value, __type.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}href uses Python identifier href
    __href = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'href'), 'href', '__httpwww_isotc211_org2005gmd_MD_DataIdentification_PropertyType_httpwww_w3_org1999xlinkhref', _ImportedBinding_bindings_v1411_write__xlink.hrefType)
    __href._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 42, 1)
    __href._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 113, 2)
    
    href = property(__href.value, __href.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}role uses Python identifier role
    __role = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'role'), 'role', '__httpwww_isotc211_org2005gmd_MD_DataIdentification_PropertyType_httpwww_w3_org1999xlinkrole', _ImportedBinding_bindings_v1411_write__xlink.roleType)
    __role._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 48, 1)
    __role._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 114, 2)
    
    role = property(__role.value, __role.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}arcrole uses Python identifier arcrole
    __arcrole = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'arcrole'), 'arcrole', '__httpwww_isotc211_org2005gmd_MD_DataIdentification_PropertyType_httpwww_w3_org1999xlinkarcrole', _ImportedBinding_bindings_v1411_write__xlink.arcroleType)
    __arcrole._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 56, 1)
    __arcrole._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 115, 2)
    
    arcrole = property(__arcrole.value, __arcrole.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}title uses Python identifier title
    __title = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'title'), 'title', '__httpwww_isotc211_org2005gmd_MD_DataIdentification_PropertyType_httpwww_w3_org1999xlinktitle', _ImportedBinding_bindings_v1411_write__xlink.titleAttrType)
    __title._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 64, 1)
    __title._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 116, 2)
    
    title = property(__title.value, __title.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}show uses Python identifier show
    __show = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'show'), 'show', '__httpwww_isotc211_org2005gmd_MD_DataIdentification_PropertyType_httpwww_w3_org1999xlinkshow', _ImportedBinding_bindings_v1411_write__xlink.showType)
    __show._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 70, 1)
    __show._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 117, 2)
    
    show = property(__show.value, __show.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}actuate uses Python identifier actuate
    __actuate = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'actuate'), 'actuate', '__httpwww_isotc211_org2005gmd_MD_DataIdentification_PropertyType_httpwww_w3_org1999xlinkactuate', _ImportedBinding_bindings_v1411_write__xlink.actuateType)
    __actuate._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 82, 1)
    __actuate._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 118, 2)
    
    actuate = property(__actuate.value, __actuate.set, None, None)

    _ElementMap.update({
        __MD_DataIdentification.name() : __MD_DataIdentification
    })
    _AttributeMap.update({
        __uuidref.name() : __uuidref,
        __nilReason.name() : __nilReason,
        __type.name() : __type,
        __href.name() : __href,
        __role.name() : __role,
        __arcrole.name() : __arcrole,
        __title.name() : __title,
        __show.name() : __show,
        __actuate.name() : __actuate
    })
_module_typeBindings.MD_DataIdentification_PropertyType = MD_DataIdentification_PropertyType
_Namespace_gmd.addCategoryObject('typeBinding', 'MD_DataIdentification_PropertyType', MD_DataIdentification_PropertyType)


# Complex type {http://www.isotc211.org/2005/gmd}MD_ServiceIdentification_Type with content type ELEMENT_ONLY
class MD_ServiceIdentification_Type (AbstractMD_Identification_Type):
    """See 19119 for further info"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_ServiceIdentification_Type')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 103, 1)
    _ElementMap = AbstractMD_Identification_Type._ElementMap.copy()
    _AttributeMap = AbstractMD_Identification_Type._AttributeMap.copy()
    # Base type is AbstractMD_Identification_Type
    
    # Element citation ({http://www.isotc211.org/2005/gmd}citation) inherited from {http://www.isotc211.org/2005/gmd}AbstractMD_Identification_Type
    
    # Element abstract ({http://www.isotc211.org/2005/gmd}abstract) inherited from {http://www.isotc211.org/2005/gmd}AbstractMD_Identification_Type
    
    # Element purpose ({http://www.isotc211.org/2005/gmd}purpose) inherited from {http://www.isotc211.org/2005/gmd}AbstractMD_Identification_Type
    
    # Element credit ({http://www.isotc211.org/2005/gmd}credit) inherited from {http://www.isotc211.org/2005/gmd}AbstractMD_Identification_Type
    
    # Element status ({http://www.isotc211.org/2005/gmd}status) inherited from {http://www.isotc211.org/2005/gmd}AbstractMD_Identification_Type
    
    # Element pointOfContact ({http://www.isotc211.org/2005/gmd}pointOfContact) inherited from {http://www.isotc211.org/2005/gmd}AbstractMD_Identification_Type
    
    # Element resourceMaintenance ({http://www.isotc211.org/2005/gmd}resourceMaintenance) inherited from {http://www.isotc211.org/2005/gmd}AbstractMD_Identification_Type
    
    # Element graphicOverview ({http://www.isotc211.org/2005/gmd}graphicOverview) inherited from {http://www.isotc211.org/2005/gmd}AbstractMD_Identification_Type
    
    # Element resourceFormat ({http://www.isotc211.org/2005/gmd}resourceFormat) inherited from {http://www.isotc211.org/2005/gmd}AbstractMD_Identification_Type
    
    # Element descriptiveKeywords ({http://www.isotc211.org/2005/gmd}descriptiveKeywords) inherited from {http://www.isotc211.org/2005/gmd}AbstractMD_Identification_Type
    
    # Element resourceSpecificUsage ({http://www.isotc211.org/2005/gmd}resourceSpecificUsage) inherited from {http://www.isotc211.org/2005/gmd}AbstractMD_Identification_Type
    
    # Element resourceConstraints ({http://www.isotc211.org/2005/gmd}resourceConstraints) inherited from {http://www.isotc211.org/2005/gmd}AbstractMD_Identification_Type
    
    # Element aggregationInfo ({http://www.isotc211.org/2005/gmd}aggregationInfo) inherited from {http://www.isotc211.org/2005/gmd}AbstractMD_Identification_Type
    
    # Attribute id inherited from {http://www.isotc211.org/2005/gco}AbstractObject_Type
    
    # Attribute uuid inherited from {http://www.isotc211.org/2005/gco}AbstractObject_Type
    _ElementMap.update({
        
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.MD_ServiceIdentification_Type = MD_ServiceIdentification_Type
_Namespace_gmd.addCategoryObject('typeBinding', 'MD_ServiceIdentification_Type', MD_ServiceIdentification_Type)


# Complex type {http://www.isotc211.org/2005/gmd}MD_ServiceIdentification_PropertyType with content type ELEMENT_ONLY
class MD_ServiceIdentification_PropertyType (pyxb.binding.basis.complexTypeDefinition):
    """Complex type {http://www.isotc211.org/2005/gmd}MD_ServiceIdentification_PropertyType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_ServiceIdentification_PropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 114, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.isotc211.org/2005/gmd}MD_ServiceIdentification uses Python identifier MD_ServiceIdentification
    __MD_ServiceIdentification = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_ServiceIdentification'), 'MD_ServiceIdentification', '__httpwww_isotc211_org2005gmd_MD_ServiceIdentification_PropertyType_httpwww_isotc211_org2005gmdMD_ServiceIdentification', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 112, 1), )

    
    MD_ServiceIdentification = property(__MD_ServiceIdentification.value, __MD_ServiceIdentification.set, None, None)

    
    # Attribute uuidref uses Python identifier uuidref
    __uuidref = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'uuidref'), 'uuidref', '__httpwww_isotc211_org2005gmd_MD_ServiceIdentification_PropertyType_uuidref', pyxb.binding.datatypes.string)
    __uuidref._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 30, 2)
    __uuidref._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 30, 2)
    
    uuidref = property(__uuidref.value, __uuidref.set, None, None)

    
    # Attribute {http://www.isotc211.org/2005/gco}nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gco, 'nilReason'), 'nilReason', '__httpwww_isotc211_org2005gmd_MD_ServiceIdentification_PropertyType_httpwww_isotc211_org2005gconilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 33, 1)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 119, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}type uses Python identifier type
    __type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'type'), 'type', '__httpwww_isotc211_org2005gmd_MD_ServiceIdentification_PropertyType_httpwww_w3_org1999xlinktype', _ImportedBinding_bindings_v1411_write__xlink.typeType, fixed=True, unicode_default='simple')
    __type._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 29, 1)
    __type._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 112, 2)
    
    type = property(__type.value, __type.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}href uses Python identifier href
    __href = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'href'), 'href', '__httpwww_isotc211_org2005gmd_MD_ServiceIdentification_PropertyType_httpwww_w3_org1999xlinkhref', _ImportedBinding_bindings_v1411_write__xlink.hrefType)
    __href._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 42, 1)
    __href._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 113, 2)
    
    href = property(__href.value, __href.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}role uses Python identifier role
    __role = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'role'), 'role', '__httpwww_isotc211_org2005gmd_MD_ServiceIdentification_PropertyType_httpwww_w3_org1999xlinkrole', _ImportedBinding_bindings_v1411_write__xlink.roleType)
    __role._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 48, 1)
    __role._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 114, 2)
    
    role = property(__role.value, __role.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}arcrole uses Python identifier arcrole
    __arcrole = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'arcrole'), 'arcrole', '__httpwww_isotc211_org2005gmd_MD_ServiceIdentification_PropertyType_httpwww_w3_org1999xlinkarcrole', _ImportedBinding_bindings_v1411_write__xlink.arcroleType)
    __arcrole._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 56, 1)
    __arcrole._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 115, 2)
    
    arcrole = property(__arcrole.value, __arcrole.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}title uses Python identifier title
    __title = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'title'), 'title', '__httpwww_isotc211_org2005gmd_MD_ServiceIdentification_PropertyType_httpwww_w3_org1999xlinktitle', _ImportedBinding_bindings_v1411_write__xlink.titleAttrType)
    __title._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 64, 1)
    __title._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 116, 2)
    
    title = property(__title.value, __title.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}show uses Python identifier show
    __show = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'show'), 'show', '__httpwww_isotc211_org2005gmd_MD_ServiceIdentification_PropertyType_httpwww_w3_org1999xlinkshow', _ImportedBinding_bindings_v1411_write__xlink.showType)
    __show._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 70, 1)
    __show._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 117, 2)
    
    show = property(__show.value, __show.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}actuate uses Python identifier actuate
    __actuate = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'actuate'), 'actuate', '__httpwww_isotc211_org2005gmd_MD_ServiceIdentification_PropertyType_httpwww_w3_org1999xlinkactuate', _ImportedBinding_bindings_v1411_write__xlink.actuateType)
    __actuate._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 82, 1)
    __actuate._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 118, 2)
    
    actuate = property(__actuate.value, __actuate.set, None, None)

    _ElementMap.update({
        __MD_ServiceIdentification.name() : __MD_ServiceIdentification
    })
    _AttributeMap.update({
        __uuidref.name() : __uuidref,
        __nilReason.name() : __nilReason,
        __type.name() : __type,
        __href.name() : __href,
        __role.name() : __role,
        __arcrole.name() : __arcrole,
        __title.name() : __title,
        __show.name() : __show,
        __actuate.name() : __actuate
    })
_module_typeBindings.MD_ServiceIdentification_PropertyType = MD_ServiceIdentification_PropertyType
_Namespace_gmd.addCategoryObject('typeBinding', 'MD_ServiceIdentification_PropertyType', MD_ServiceIdentification_PropertyType)


# Complex type {http://www.isotc211.org/2005/gmd}MD_RepresentativeFraction_PropertyType with content type ELEMENT_ONLY
class MD_RepresentativeFraction_PropertyType (pyxb.binding.basis.complexTypeDefinition):
    """Complex type {http://www.isotc211.org/2005/gmd}MD_RepresentativeFraction_PropertyType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_RepresentativeFraction_PropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 134, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.isotc211.org/2005/gmd}MD_RepresentativeFraction uses Python identifier MD_RepresentativeFraction
    __MD_RepresentativeFraction = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_RepresentativeFraction'), 'MD_RepresentativeFraction', '__httpwww_isotc211_org2005gmd_MD_RepresentativeFraction_PropertyType_httpwww_isotc211_org2005gmdMD_RepresentativeFraction', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 132, 1), )

    
    MD_RepresentativeFraction = property(__MD_RepresentativeFraction.value, __MD_RepresentativeFraction.set, None, None)

    
    # Attribute uuidref uses Python identifier uuidref
    __uuidref = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'uuidref'), 'uuidref', '__httpwww_isotc211_org2005gmd_MD_RepresentativeFraction_PropertyType_uuidref', pyxb.binding.datatypes.string)
    __uuidref._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 30, 2)
    __uuidref._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 30, 2)
    
    uuidref = property(__uuidref.value, __uuidref.set, None, None)

    
    # Attribute {http://www.isotc211.org/2005/gco}nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gco, 'nilReason'), 'nilReason', '__httpwww_isotc211_org2005gmd_MD_RepresentativeFraction_PropertyType_httpwww_isotc211_org2005gconilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 33, 1)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 139, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}type uses Python identifier type
    __type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'type'), 'type', '__httpwww_isotc211_org2005gmd_MD_RepresentativeFraction_PropertyType_httpwww_w3_org1999xlinktype', _ImportedBinding_bindings_v1411_write__xlink.typeType, fixed=True, unicode_default='simple')
    __type._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 29, 1)
    __type._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 112, 2)
    
    type = property(__type.value, __type.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}href uses Python identifier href
    __href = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'href'), 'href', '__httpwww_isotc211_org2005gmd_MD_RepresentativeFraction_PropertyType_httpwww_w3_org1999xlinkhref', _ImportedBinding_bindings_v1411_write__xlink.hrefType)
    __href._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 42, 1)
    __href._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 113, 2)
    
    href = property(__href.value, __href.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}role uses Python identifier role
    __role = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'role'), 'role', '__httpwww_isotc211_org2005gmd_MD_RepresentativeFraction_PropertyType_httpwww_w3_org1999xlinkrole', _ImportedBinding_bindings_v1411_write__xlink.roleType)
    __role._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 48, 1)
    __role._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 114, 2)
    
    role = property(__role.value, __role.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}arcrole uses Python identifier arcrole
    __arcrole = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'arcrole'), 'arcrole', '__httpwww_isotc211_org2005gmd_MD_RepresentativeFraction_PropertyType_httpwww_w3_org1999xlinkarcrole', _ImportedBinding_bindings_v1411_write__xlink.arcroleType)
    __arcrole._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 56, 1)
    __arcrole._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 115, 2)
    
    arcrole = property(__arcrole.value, __arcrole.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}title uses Python identifier title
    __title = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'title'), 'title', '__httpwww_isotc211_org2005gmd_MD_RepresentativeFraction_PropertyType_httpwww_w3_org1999xlinktitle', _ImportedBinding_bindings_v1411_write__xlink.titleAttrType)
    __title._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 64, 1)
    __title._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 116, 2)
    
    title = property(__title.value, __title.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}show uses Python identifier show
    __show = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'show'), 'show', '__httpwww_isotc211_org2005gmd_MD_RepresentativeFraction_PropertyType_httpwww_w3_org1999xlinkshow', _ImportedBinding_bindings_v1411_write__xlink.showType)
    __show._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 70, 1)
    __show._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 117, 2)
    
    show = property(__show.value, __show.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}actuate uses Python identifier actuate
    __actuate = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'actuate'), 'actuate', '__httpwww_isotc211_org2005gmd_MD_RepresentativeFraction_PropertyType_httpwww_w3_org1999xlinkactuate', _ImportedBinding_bindings_v1411_write__xlink.actuateType)
    __actuate._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 82, 1)
    __actuate._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 118, 2)
    
    actuate = property(__actuate.value, __actuate.set, None, None)

    _ElementMap.update({
        __MD_RepresentativeFraction.name() : __MD_RepresentativeFraction
    })
    _AttributeMap.update({
        __uuidref.name() : __uuidref,
        __nilReason.name() : __nilReason,
        __type.name() : __type,
        __href.name() : __href,
        __role.name() : __role,
        __arcrole.name() : __arcrole,
        __title.name() : __title,
        __show.name() : __show,
        __actuate.name() : __actuate
    })
_module_typeBindings.MD_RepresentativeFraction_PropertyType = MD_RepresentativeFraction_PropertyType
_Namespace_gmd.addCategoryObject('typeBinding', 'MD_RepresentativeFraction_PropertyType', MD_RepresentativeFraction_PropertyType)


# Complex type {http://www.isotc211.org/2005/gmd}MD_Usage_PropertyType with content type ELEMENT_ONLY
class MD_Usage_PropertyType (pyxb.binding.basis.complexTypeDefinition):
    """Complex type {http://www.isotc211.org/2005/gmd}MD_Usage_PropertyType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_Usage_PropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 160, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.isotc211.org/2005/gmd}MD_Usage uses Python identifier MD_Usage
    __MD_Usage = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_Usage'), 'MD_Usage', '__httpwww_isotc211_org2005gmd_MD_Usage_PropertyType_httpwww_isotc211_org2005gmdMD_Usage', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 158, 1), )

    
    MD_Usage = property(__MD_Usage.value, __MD_Usage.set, None, None)

    
    # Attribute uuidref uses Python identifier uuidref
    __uuidref = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'uuidref'), 'uuidref', '__httpwww_isotc211_org2005gmd_MD_Usage_PropertyType_uuidref', pyxb.binding.datatypes.string)
    __uuidref._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 30, 2)
    __uuidref._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 30, 2)
    
    uuidref = property(__uuidref.value, __uuidref.set, None, None)

    
    # Attribute {http://www.isotc211.org/2005/gco}nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gco, 'nilReason'), 'nilReason', '__httpwww_isotc211_org2005gmd_MD_Usage_PropertyType_httpwww_isotc211_org2005gconilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 33, 1)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 165, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}type uses Python identifier type
    __type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'type'), 'type', '__httpwww_isotc211_org2005gmd_MD_Usage_PropertyType_httpwww_w3_org1999xlinktype', _ImportedBinding_bindings_v1411_write__xlink.typeType, fixed=True, unicode_default='simple')
    __type._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 29, 1)
    __type._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 112, 2)
    
    type = property(__type.value, __type.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}href uses Python identifier href
    __href = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'href'), 'href', '__httpwww_isotc211_org2005gmd_MD_Usage_PropertyType_httpwww_w3_org1999xlinkhref', _ImportedBinding_bindings_v1411_write__xlink.hrefType)
    __href._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 42, 1)
    __href._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 113, 2)
    
    href = property(__href.value, __href.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}role uses Python identifier role
    __role = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'role'), 'role', '__httpwww_isotc211_org2005gmd_MD_Usage_PropertyType_httpwww_w3_org1999xlinkrole', _ImportedBinding_bindings_v1411_write__xlink.roleType)
    __role._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 48, 1)
    __role._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 114, 2)
    
    role = property(__role.value, __role.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}arcrole uses Python identifier arcrole
    __arcrole = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'arcrole'), 'arcrole', '__httpwww_isotc211_org2005gmd_MD_Usage_PropertyType_httpwww_w3_org1999xlinkarcrole', _ImportedBinding_bindings_v1411_write__xlink.arcroleType)
    __arcrole._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 56, 1)
    __arcrole._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 115, 2)
    
    arcrole = property(__arcrole.value, __arcrole.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}title uses Python identifier title
    __title = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'title'), 'title', '__httpwww_isotc211_org2005gmd_MD_Usage_PropertyType_httpwww_w3_org1999xlinktitle', _ImportedBinding_bindings_v1411_write__xlink.titleAttrType)
    __title._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 64, 1)
    __title._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 116, 2)
    
    title = property(__title.value, __title.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}show uses Python identifier show
    __show = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'show'), 'show', '__httpwww_isotc211_org2005gmd_MD_Usage_PropertyType_httpwww_w3_org1999xlinkshow', _ImportedBinding_bindings_v1411_write__xlink.showType)
    __show._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 70, 1)
    __show._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 117, 2)
    
    show = property(__show.value, __show.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}actuate uses Python identifier actuate
    __actuate = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'actuate'), 'actuate', '__httpwww_isotc211_org2005gmd_MD_Usage_PropertyType_httpwww_w3_org1999xlinkactuate', _ImportedBinding_bindings_v1411_write__xlink.actuateType)
    __actuate._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 82, 1)
    __actuate._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 118, 2)
    
    actuate = property(__actuate.value, __actuate.set, None, None)

    _ElementMap.update({
        __MD_Usage.name() : __MD_Usage
    })
    _AttributeMap.update({
        __uuidref.name() : __uuidref,
        __nilReason.name() : __nilReason,
        __type.name() : __type,
        __href.name() : __href,
        __role.name() : __role,
        __arcrole.name() : __arcrole,
        __title.name() : __title,
        __show.name() : __show,
        __actuate.name() : __actuate
    })
_module_typeBindings.MD_Usage_PropertyType = MD_Usage_PropertyType
_Namespace_gmd.addCategoryObject('typeBinding', 'MD_Usage_PropertyType', MD_Usage_PropertyType)


# Complex type {http://www.isotc211.org/2005/gmd}MD_Keywords_PropertyType with content type ELEMENT_ONLY
class MD_Keywords_PropertyType (pyxb.binding.basis.complexTypeDefinition):
    """Complex type {http://www.isotc211.org/2005/gmd}MD_Keywords_PropertyType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_Keywords_PropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 185, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.isotc211.org/2005/gmd}MD_Keywords uses Python identifier MD_Keywords
    __MD_Keywords = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_Keywords'), 'MD_Keywords', '__httpwww_isotc211_org2005gmd_MD_Keywords_PropertyType_httpwww_isotc211_org2005gmdMD_Keywords', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 183, 1), )

    
    MD_Keywords = property(__MD_Keywords.value, __MD_Keywords.set, None, None)

    
    # Attribute uuidref uses Python identifier uuidref
    __uuidref = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'uuidref'), 'uuidref', '__httpwww_isotc211_org2005gmd_MD_Keywords_PropertyType_uuidref', pyxb.binding.datatypes.string)
    __uuidref._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 30, 2)
    __uuidref._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 30, 2)
    
    uuidref = property(__uuidref.value, __uuidref.set, None, None)

    
    # Attribute {http://www.isotc211.org/2005/gco}nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gco, 'nilReason'), 'nilReason', '__httpwww_isotc211_org2005gmd_MD_Keywords_PropertyType_httpwww_isotc211_org2005gconilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 33, 1)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 190, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}type uses Python identifier type
    __type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'type'), 'type', '__httpwww_isotc211_org2005gmd_MD_Keywords_PropertyType_httpwww_w3_org1999xlinktype', _ImportedBinding_bindings_v1411_write__xlink.typeType, fixed=True, unicode_default='simple')
    __type._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 29, 1)
    __type._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 112, 2)
    
    type = property(__type.value, __type.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}href uses Python identifier href
    __href = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'href'), 'href', '__httpwww_isotc211_org2005gmd_MD_Keywords_PropertyType_httpwww_w3_org1999xlinkhref', _ImportedBinding_bindings_v1411_write__xlink.hrefType)
    __href._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 42, 1)
    __href._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 113, 2)
    
    href = property(__href.value, __href.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}role uses Python identifier role
    __role = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'role'), 'role', '__httpwww_isotc211_org2005gmd_MD_Keywords_PropertyType_httpwww_w3_org1999xlinkrole', _ImportedBinding_bindings_v1411_write__xlink.roleType)
    __role._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 48, 1)
    __role._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 114, 2)
    
    role = property(__role.value, __role.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}arcrole uses Python identifier arcrole
    __arcrole = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'arcrole'), 'arcrole', '__httpwww_isotc211_org2005gmd_MD_Keywords_PropertyType_httpwww_w3_org1999xlinkarcrole', _ImportedBinding_bindings_v1411_write__xlink.arcroleType)
    __arcrole._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 56, 1)
    __arcrole._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 115, 2)
    
    arcrole = property(__arcrole.value, __arcrole.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}title uses Python identifier title
    __title = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'title'), 'title', '__httpwww_isotc211_org2005gmd_MD_Keywords_PropertyType_httpwww_w3_org1999xlinktitle', _ImportedBinding_bindings_v1411_write__xlink.titleAttrType)
    __title._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 64, 1)
    __title._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 116, 2)
    
    title = property(__title.value, __title.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}show uses Python identifier show
    __show = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'show'), 'show', '__httpwww_isotc211_org2005gmd_MD_Keywords_PropertyType_httpwww_w3_org1999xlinkshow', _ImportedBinding_bindings_v1411_write__xlink.showType)
    __show._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 70, 1)
    __show._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 117, 2)
    
    show = property(__show.value, __show.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}actuate uses Python identifier actuate
    __actuate = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'actuate'), 'actuate', '__httpwww_isotc211_org2005gmd_MD_Keywords_PropertyType_httpwww_w3_org1999xlinkactuate', _ImportedBinding_bindings_v1411_write__xlink.actuateType)
    __actuate._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 82, 1)
    __actuate._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 118, 2)
    
    actuate = property(__actuate.value, __actuate.set, None, None)

    _ElementMap.update({
        __MD_Keywords.name() : __MD_Keywords
    })
    _AttributeMap.update({
        __uuidref.name() : __uuidref,
        __nilReason.name() : __nilReason,
        __type.name() : __type,
        __href.name() : __href,
        __role.name() : __role,
        __arcrole.name() : __arcrole,
        __title.name() : __title,
        __show.name() : __show,
        __actuate.name() : __actuate
    })
_module_typeBindings.MD_Keywords_PropertyType = MD_Keywords_PropertyType
_Namespace_gmd.addCategoryObject('typeBinding', 'MD_Keywords_PropertyType', MD_Keywords_PropertyType)


# Complex type {http://www.isotc211.org/2005/gmd}DS_Association_PropertyType with content type ELEMENT_ONLY
class DS_Association_PropertyType (pyxb.binding.basis.complexTypeDefinition):
    """Complex type {http://www.isotc211.org/2005/gmd}DS_Association_PropertyType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'DS_Association_PropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 203, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.isotc211.org/2005/gmd}DS_Association uses Python identifier DS_Association
    __DS_Association = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'DS_Association'), 'DS_Association', '__httpwww_isotc211_org2005gmd_DS_Association_PropertyType_httpwww_isotc211_org2005gmdDS_Association', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 201, 1), )

    
    DS_Association = property(__DS_Association.value, __DS_Association.set, None, None)

    
    # Attribute uuidref uses Python identifier uuidref
    __uuidref = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'uuidref'), 'uuidref', '__httpwww_isotc211_org2005gmd_DS_Association_PropertyType_uuidref', pyxb.binding.datatypes.string)
    __uuidref._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 30, 2)
    __uuidref._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 30, 2)
    
    uuidref = property(__uuidref.value, __uuidref.set, None, None)

    
    # Attribute {http://www.isotc211.org/2005/gco}nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gco, 'nilReason'), 'nilReason', '__httpwww_isotc211_org2005gmd_DS_Association_PropertyType_httpwww_isotc211_org2005gconilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 33, 1)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 208, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}type uses Python identifier type
    __type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'type'), 'type', '__httpwww_isotc211_org2005gmd_DS_Association_PropertyType_httpwww_w3_org1999xlinktype', _ImportedBinding_bindings_v1411_write__xlink.typeType, fixed=True, unicode_default='simple')
    __type._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 29, 1)
    __type._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 112, 2)
    
    type = property(__type.value, __type.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}href uses Python identifier href
    __href = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'href'), 'href', '__httpwww_isotc211_org2005gmd_DS_Association_PropertyType_httpwww_w3_org1999xlinkhref', _ImportedBinding_bindings_v1411_write__xlink.hrefType)
    __href._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 42, 1)
    __href._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 113, 2)
    
    href = property(__href.value, __href.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}role uses Python identifier role
    __role = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'role'), 'role', '__httpwww_isotc211_org2005gmd_DS_Association_PropertyType_httpwww_w3_org1999xlinkrole', _ImportedBinding_bindings_v1411_write__xlink.roleType)
    __role._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 48, 1)
    __role._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 114, 2)
    
    role = property(__role.value, __role.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}arcrole uses Python identifier arcrole
    __arcrole = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'arcrole'), 'arcrole', '__httpwww_isotc211_org2005gmd_DS_Association_PropertyType_httpwww_w3_org1999xlinkarcrole', _ImportedBinding_bindings_v1411_write__xlink.arcroleType)
    __arcrole._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 56, 1)
    __arcrole._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 115, 2)
    
    arcrole = property(__arcrole.value, __arcrole.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}title uses Python identifier title
    __title = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'title'), 'title', '__httpwww_isotc211_org2005gmd_DS_Association_PropertyType_httpwww_w3_org1999xlinktitle', _ImportedBinding_bindings_v1411_write__xlink.titleAttrType)
    __title._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 64, 1)
    __title._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 116, 2)
    
    title = property(__title.value, __title.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}show uses Python identifier show
    __show = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'show'), 'show', '__httpwww_isotc211_org2005gmd_DS_Association_PropertyType_httpwww_w3_org1999xlinkshow', _ImportedBinding_bindings_v1411_write__xlink.showType)
    __show._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 70, 1)
    __show._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 117, 2)
    
    show = property(__show.value, __show.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}actuate uses Python identifier actuate
    __actuate = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'actuate'), 'actuate', '__httpwww_isotc211_org2005gmd_DS_Association_PropertyType_httpwww_w3_org1999xlinkactuate', _ImportedBinding_bindings_v1411_write__xlink.actuateType)
    __actuate._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 82, 1)
    __actuate._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 118, 2)
    
    actuate = property(__actuate.value, __actuate.set, None, None)

    _ElementMap.update({
        __DS_Association.name() : __DS_Association
    })
    _AttributeMap.update({
        __uuidref.name() : __uuidref,
        __nilReason.name() : __nilReason,
        __type.name() : __type,
        __href.name() : __href,
        __role.name() : __role,
        __arcrole.name() : __arcrole,
        __title.name() : __title,
        __show.name() : __show,
        __actuate.name() : __actuate
    })
_module_typeBindings.DS_Association_PropertyType = DS_Association_PropertyType
_Namespace_gmd.addCategoryObject('typeBinding', 'DS_Association_PropertyType', DS_Association_PropertyType)


# Complex type {http://www.isotc211.org/2005/gmd}MD_AggregateInformation_PropertyType with content type ELEMENT_ONLY
class MD_AggregateInformation_PropertyType (pyxb.binding.basis.complexTypeDefinition):
    """Complex type {http://www.isotc211.org/2005/gmd}MD_AggregateInformation_PropertyType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_AggregateInformation_PropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 229, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.isotc211.org/2005/gmd}MD_AggregateInformation uses Python identifier MD_AggregateInformation
    __MD_AggregateInformation = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_AggregateInformation'), 'MD_AggregateInformation', '__httpwww_isotc211_org2005gmd_MD_AggregateInformation_PropertyType_httpwww_isotc211_org2005gmdMD_AggregateInformation', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 227, 1), )

    
    MD_AggregateInformation = property(__MD_AggregateInformation.value, __MD_AggregateInformation.set, None, None)

    
    # Attribute uuidref uses Python identifier uuidref
    __uuidref = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'uuidref'), 'uuidref', '__httpwww_isotc211_org2005gmd_MD_AggregateInformation_PropertyType_uuidref', pyxb.binding.datatypes.string)
    __uuidref._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 30, 2)
    __uuidref._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 30, 2)
    
    uuidref = property(__uuidref.value, __uuidref.set, None, None)

    
    # Attribute {http://www.isotc211.org/2005/gco}nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gco, 'nilReason'), 'nilReason', '__httpwww_isotc211_org2005gmd_MD_AggregateInformation_PropertyType_httpwww_isotc211_org2005gconilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 33, 1)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 234, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}type uses Python identifier type
    __type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'type'), 'type', '__httpwww_isotc211_org2005gmd_MD_AggregateInformation_PropertyType_httpwww_w3_org1999xlinktype', _ImportedBinding_bindings_v1411_write__xlink.typeType, fixed=True, unicode_default='simple')
    __type._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 29, 1)
    __type._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 112, 2)
    
    type = property(__type.value, __type.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}href uses Python identifier href
    __href = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'href'), 'href', '__httpwww_isotc211_org2005gmd_MD_AggregateInformation_PropertyType_httpwww_w3_org1999xlinkhref', _ImportedBinding_bindings_v1411_write__xlink.hrefType)
    __href._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 42, 1)
    __href._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 113, 2)
    
    href = property(__href.value, __href.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}role uses Python identifier role
    __role = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'role'), 'role', '__httpwww_isotc211_org2005gmd_MD_AggregateInformation_PropertyType_httpwww_w3_org1999xlinkrole', _ImportedBinding_bindings_v1411_write__xlink.roleType)
    __role._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 48, 1)
    __role._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 114, 2)
    
    role = property(__role.value, __role.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}arcrole uses Python identifier arcrole
    __arcrole = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'arcrole'), 'arcrole', '__httpwww_isotc211_org2005gmd_MD_AggregateInformation_PropertyType_httpwww_w3_org1999xlinkarcrole', _ImportedBinding_bindings_v1411_write__xlink.arcroleType)
    __arcrole._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 56, 1)
    __arcrole._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 115, 2)
    
    arcrole = property(__arcrole.value, __arcrole.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}title uses Python identifier title
    __title = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'title'), 'title', '__httpwww_isotc211_org2005gmd_MD_AggregateInformation_PropertyType_httpwww_w3_org1999xlinktitle', _ImportedBinding_bindings_v1411_write__xlink.titleAttrType)
    __title._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 64, 1)
    __title._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 116, 2)
    
    title = property(__title.value, __title.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}show uses Python identifier show
    __show = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'show'), 'show', '__httpwww_isotc211_org2005gmd_MD_AggregateInformation_PropertyType_httpwww_w3_org1999xlinkshow', _ImportedBinding_bindings_v1411_write__xlink.showType)
    __show._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 70, 1)
    __show._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 117, 2)
    
    show = property(__show.value, __show.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}actuate uses Python identifier actuate
    __actuate = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'actuate'), 'actuate', '__httpwww_isotc211_org2005gmd_MD_AggregateInformation_PropertyType_httpwww_w3_org1999xlinkactuate', _ImportedBinding_bindings_v1411_write__xlink.actuateType)
    __actuate._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 82, 1)
    __actuate._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 118, 2)
    
    actuate = property(__actuate.value, __actuate.set, None, None)

    _ElementMap.update({
        __MD_AggregateInformation.name() : __MD_AggregateInformation
    })
    _AttributeMap.update({
        __uuidref.name() : __uuidref,
        __nilReason.name() : __nilReason,
        __type.name() : __type,
        __href.name() : __href,
        __role.name() : __role,
        __arcrole.name() : __arcrole,
        __title.name() : __title,
        __show.name() : __show,
        __actuate.name() : __actuate
    })
_module_typeBindings.MD_AggregateInformation_PropertyType = MD_AggregateInformation_PropertyType
_Namespace_gmd.addCategoryObject('typeBinding', 'MD_AggregateInformation_PropertyType', MD_AggregateInformation_PropertyType)


# Complex type {http://www.isotc211.org/2005/gmd}MD_Resolution_PropertyType with content type ELEMENT_ONLY
class MD_Resolution_PropertyType (pyxb.binding.basis.complexTypeDefinition):
    """Complex type {http://www.isotc211.org/2005/gmd}MD_Resolution_PropertyType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_Resolution_PropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 246, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.isotc211.org/2005/gmd}MD_Resolution uses Python identifier MD_Resolution
    __MD_Resolution = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_Resolution'), 'MD_Resolution', '__httpwww_isotc211_org2005gmd_MD_Resolution_PropertyType_httpwww_isotc211_org2005gmdMD_Resolution', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 244, 1), )

    
    MD_Resolution = property(__MD_Resolution.value, __MD_Resolution.set, None, None)

    
    # Attribute {http://www.isotc211.org/2005/gco}nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gco, 'nilReason'), 'nilReason', '__httpwww_isotc211_org2005gmd_MD_Resolution_PropertyType_httpwww_isotc211_org2005gconilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 33, 1)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 250, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    _ElementMap.update({
        __MD_Resolution.name() : __MD_Resolution
    })
    _AttributeMap.update({
        __nilReason.name() : __nilReason
    })
_module_typeBindings.MD_Resolution_PropertyType = MD_Resolution_PropertyType
_Namespace_gmd.addCategoryObject('typeBinding', 'MD_Resolution_PropertyType', MD_Resolution_PropertyType)


# Complex type {http://www.isotc211.org/2005/gmd}MD_TopicCategoryCode_PropertyType with content type ELEMENT_ONLY
class MD_TopicCategoryCode_PropertyType (pyxb.binding.basis.complexTypeDefinition):
    """Complex type {http://www.isotc211.org/2005/gmd}MD_TopicCategoryCode_PropertyType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_TopicCategoryCode_PropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 282, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.isotc211.org/2005/gmd}MD_TopicCategoryCode uses Python identifier MD_TopicCategoryCode
    __MD_TopicCategoryCode = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_TopicCategoryCode'), 'MD_TopicCategoryCode', '__httpwww_isotc211_org2005gmd_MD_TopicCategoryCode_PropertyType_httpwww_isotc211_org2005gmdMD_TopicCategoryCode', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 280, 1), )

    
    MD_TopicCategoryCode = property(__MD_TopicCategoryCode.value, __MD_TopicCategoryCode.set, None, None)

    
    # Attribute {http://www.isotc211.org/2005/gco}nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gco, 'nilReason'), 'nilReason', '__httpwww_isotc211_org2005gmd_MD_TopicCategoryCode_PropertyType_httpwww_isotc211_org2005gconilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 33, 1)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 286, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    _ElementMap.update({
        __MD_TopicCategoryCode.name() : __MD_TopicCategoryCode
    })
    _AttributeMap.update({
        __nilReason.name() : __nilReason
    })
_module_typeBindings.MD_TopicCategoryCode_PropertyType = MD_TopicCategoryCode_PropertyType
_Namespace_gmd.addCategoryObject('typeBinding', 'MD_TopicCategoryCode_PropertyType', MD_TopicCategoryCode_PropertyType)


# Complex type {http://www.isotc211.org/2005/gmd}MD_CharacterSetCode_PropertyType with content type ELEMENT_ONLY
class MD_CharacterSetCode_PropertyType (pyxb.binding.basis.complexTypeDefinition):
    """Complex type {http://www.isotc211.org/2005/gmd}MD_CharacterSetCode_PropertyType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_CharacterSetCode_PropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 292, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.isotc211.org/2005/gmd}MD_CharacterSetCode uses Python identifier MD_CharacterSetCode
    __MD_CharacterSetCode = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_CharacterSetCode'), 'MD_CharacterSetCode', '__httpwww_isotc211_org2005gmd_MD_CharacterSetCode_PropertyType_httpwww_isotc211_org2005gmdMD_CharacterSetCode', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 290, 1), )

    
    MD_CharacterSetCode = property(__MD_CharacterSetCode.value, __MD_CharacterSetCode.set, None, None)

    
    # Attribute {http://www.isotc211.org/2005/gco}nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gco, 'nilReason'), 'nilReason', '__httpwww_isotc211_org2005gmd_MD_CharacterSetCode_PropertyType_httpwww_isotc211_org2005gconilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 33, 1)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 296, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    _ElementMap.update({
        __MD_CharacterSetCode.name() : __MD_CharacterSetCode
    })
    _AttributeMap.update({
        __nilReason.name() : __nilReason
    })
_module_typeBindings.MD_CharacterSetCode_PropertyType = MD_CharacterSetCode_PropertyType
_Namespace_gmd.addCategoryObject('typeBinding', 'MD_CharacterSetCode_PropertyType', MD_CharacterSetCode_PropertyType)


# Complex type {http://www.isotc211.org/2005/gmd}MD_SpatialRepresentationTypeCode_PropertyType with content type ELEMENT_ONLY
class MD_SpatialRepresentationTypeCode_PropertyType (pyxb.binding.basis.complexTypeDefinition):
    """Complex type {http://www.isotc211.org/2005/gmd}MD_SpatialRepresentationTypeCode_PropertyType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_SpatialRepresentationTypeCode_PropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 302, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.isotc211.org/2005/gmd}MD_SpatialRepresentationTypeCode uses Python identifier MD_SpatialRepresentationTypeCode
    __MD_SpatialRepresentationTypeCode = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_SpatialRepresentationTypeCode'), 'MD_SpatialRepresentationTypeCode', '__httpwww_isotc211_org2005gmd_MD_SpatialRepresentationTypeCode_PropertyType_httpwww_isotc211_org2005gmdMD_SpatialRepresentationTypeCode', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 300, 1), )

    
    MD_SpatialRepresentationTypeCode = property(__MD_SpatialRepresentationTypeCode.value, __MD_SpatialRepresentationTypeCode.set, None, None)

    
    # Attribute {http://www.isotc211.org/2005/gco}nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gco, 'nilReason'), 'nilReason', '__httpwww_isotc211_org2005gmd_MD_SpatialRepresentationTypeCode_PropertyType_httpwww_isotc211_org2005gconilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 33, 1)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 306, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    _ElementMap.update({
        __MD_SpatialRepresentationTypeCode.name() : __MD_SpatialRepresentationTypeCode
    })
    _AttributeMap.update({
        __nilReason.name() : __nilReason
    })
_module_typeBindings.MD_SpatialRepresentationTypeCode_PropertyType = MD_SpatialRepresentationTypeCode_PropertyType
_Namespace_gmd.addCategoryObject('typeBinding', 'MD_SpatialRepresentationTypeCode_PropertyType', MD_SpatialRepresentationTypeCode_PropertyType)


# Complex type {http://www.isotc211.org/2005/gmd}MD_ProgressCode_PropertyType with content type ELEMENT_ONLY
class MD_ProgressCode_PropertyType (pyxb.binding.basis.complexTypeDefinition):
    """Complex type {http://www.isotc211.org/2005/gmd}MD_ProgressCode_PropertyType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_ProgressCode_PropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 312, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.isotc211.org/2005/gmd}MD_ProgressCode uses Python identifier MD_ProgressCode
    __MD_ProgressCode = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_ProgressCode'), 'MD_ProgressCode', '__httpwww_isotc211_org2005gmd_MD_ProgressCode_PropertyType_httpwww_isotc211_org2005gmdMD_ProgressCode', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 310, 1), )

    
    MD_ProgressCode = property(__MD_ProgressCode.value, __MD_ProgressCode.set, None, None)

    
    # Attribute {http://www.isotc211.org/2005/gco}nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gco, 'nilReason'), 'nilReason', '__httpwww_isotc211_org2005gmd_MD_ProgressCode_PropertyType_httpwww_isotc211_org2005gconilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 33, 1)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 316, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    _ElementMap.update({
        __MD_ProgressCode.name() : __MD_ProgressCode
    })
    _AttributeMap.update({
        __nilReason.name() : __nilReason
    })
_module_typeBindings.MD_ProgressCode_PropertyType = MD_ProgressCode_PropertyType
_Namespace_gmd.addCategoryObject('typeBinding', 'MD_ProgressCode_PropertyType', MD_ProgressCode_PropertyType)


# Complex type {http://www.isotc211.org/2005/gmd}MD_KeywordTypeCode_PropertyType with content type ELEMENT_ONLY
class MD_KeywordTypeCode_PropertyType (pyxb.binding.basis.complexTypeDefinition):
    """Complex type {http://www.isotc211.org/2005/gmd}MD_KeywordTypeCode_PropertyType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_KeywordTypeCode_PropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 322, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.isotc211.org/2005/gmd}MD_KeywordTypeCode uses Python identifier MD_KeywordTypeCode
    __MD_KeywordTypeCode = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_KeywordTypeCode'), 'MD_KeywordTypeCode', '__httpwww_isotc211_org2005gmd_MD_KeywordTypeCode_PropertyType_httpwww_isotc211_org2005gmdMD_KeywordTypeCode', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 320, 1), )

    
    MD_KeywordTypeCode = property(__MD_KeywordTypeCode.value, __MD_KeywordTypeCode.set, None, None)

    
    # Attribute {http://www.isotc211.org/2005/gco}nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gco, 'nilReason'), 'nilReason', '__httpwww_isotc211_org2005gmd_MD_KeywordTypeCode_PropertyType_httpwww_isotc211_org2005gconilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 33, 1)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 326, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    _ElementMap.update({
        __MD_KeywordTypeCode.name() : __MD_KeywordTypeCode
    })
    _AttributeMap.update({
        __nilReason.name() : __nilReason
    })
_module_typeBindings.MD_KeywordTypeCode_PropertyType = MD_KeywordTypeCode_PropertyType
_Namespace_gmd.addCategoryObject('typeBinding', 'MD_KeywordTypeCode_PropertyType', MD_KeywordTypeCode_PropertyType)


# Complex type {http://www.isotc211.org/2005/gmd}DS_AssociationTypeCode_PropertyType with content type ELEMENT_ONLY
class DS_AssociationTypeCode_PropertyType (pyxb.binding.basis.complexTypeDefinition):
    """Complex type {http://www.isotc211.org/2005/gmd}DS_AssociationTypeCode_PropertyType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'DS_AssociationTypeCode_PropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 332, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.isotc211.org/2005/gmd}DS_AssociationTypeCode uses Python identifier DS_AssociationTypeCode
    __DS_AssociationTypeCode = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'DS_AssociationTypeCode'), 'DS_AssociationTypeCode', '__httpwww_isotc211_org2005gmd_DS_AssociationTypeCode_PropertyType_httpwww_isotc211_org2005gmdDS_AssociationTypeCode', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 330, 1), )

    
    DS_AssociationTypeCode = property(__DS_AssociationTypeCode.value, __DS_AssociationTypeCode.set, None, None)

    
    # Attribute {http://www.isotc211.org/2005/gco}nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gco, 'nilReason'), 'nilReason', '__httpwww_isotc211_org2005gmd_DS_AssociationTypeCode_PropertyType_httpwww_isotc211_org2005gconilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 33, 1)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 336, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    _ElementMap.update({
        __DS_AssociationTypeCode.name() : __DS_AssociationTypeCode
    })
    _AttributeMap.update({
        __nilReason.name() : __nilReason
    })
_module_typeBindings.DS_AssociationTypeCode_PropertyType = DS_AssociationTypeCode_PropertyType
_Namespace_gmd.addCategoryObject('typeBinding', 'DS_AssociationTypeCode_PropertyType', DS_AssociationTypeCode_PropertyType)


# Complex type {http://www.isotc211.org/2005/gmd}DS_InitiativeTypeCode_PropertyType with content type ELEMENT_ONLY
class DS_InitiativeTypeCode_PropertyType (pyxb.binding.basis.complexTypeDefinition):
    """Complex type {http://www.isotc211.org/2005/gmd}DS_InitiativeTypeCode_PropertyType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'DS_InitiativeTypeCode_PropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 342, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.isotc211.org/2005/gmd}DS_InitiativeTypeCode uses Python identifier DS_InitiativeTypeCode
    __DS_InitiativeTypeCode = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'DS_InitiativeTypeCode'), 'DS_InitiativeTypeCode', '__httpwww_isotc211_org2005gmd_DS_InitiativeTypeCode_PropertyType_httpwww_isotc211_org2005gmdDS_InitiativeTypeCode', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 340, 1), )

    
    DS_InitiativeTypeCode = property(__DS_InitiativeTypeCode.value, __DS_InitiativeTypeCode.set, None, None)

    
    # Attribute {http://www.isotc211.org/2005/gco}nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gco, 'nilReason'), 'nilReason', '__httpwww_isotc211_org2005gmd_DS_InitiativeTypeCode_PropertyType_httpwww_isotc211_org2005gconilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 33, 1)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 346, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    _ElementMap.update({
        __DS_InitiativeTypeCode.name() : __DS_InitiativeTypeCode
    })
    _AttributeMap.update({
        __nilReason.name() : __nilReason
    })
_module_typeBindings.DS_InitiativeTypeCode_PropertyType = DS_InitiativeTypeCode_PropertyType
_Namespace_gmd.addCategoryObject('typeBinding', 'DS_InitiativeTypeCode_PropertyType', DS_InitiativeTypeCode_PropertyType)


# Complex type {http://www.isotc211.org/2005/gmd}MD_MaintenanceInformation_PropertyType with content type ELEMENT_ONLY
class MD_MaintenanceInformation_PropertyType (pyxb.binding.basis.complexTypeDefinition):
    """Complex type {http://www.isotc211.org/2005/gmd}MD_MaintenanceInformation_PropertyType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_MaintenanceInformation_PropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/maintenance.xsd', 36, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.isotc211.org/2005/gmd}MD_MaintenanceInformation uses Python identifier MD_MaintenanceInformation
    __MD_MaintenanceInformation = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_MaintenanceInformation'), 'MD_MaintenanceInformation', '__httpwww_isotc211_org2005gmd_MD_MaintenanceInformation_PropertyType_httpwww_isotc211_org2005gmdMD_MaintenanceInformation', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/maintenance.xsd', 34, 1), )

    
    MD_MaintenanceInformation = property(__MD_MaintenanceInformation.value, __MD_MaintenanceInformation.set, None, None)

    
    # Attribute uuidref uses Python identifier uuidref
    __uuidref = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'uuidref'), 'uuidref', '__httpwww_isotc211_org2005gmd_MD_MaintenanceInformation_PropertyType_uuidref', pyxb.binding.datatypes.string)
    __uuidref._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 30, 2)
    __uuidref._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 30, 2)
    
    uuidref = property(__uuidref.value, __uuidref.set, None, None)

    
    # Attribute {http://www.isotc211.org/2005/gco}nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gco, 'nilReason'), 'nilReason', '__httpwww_isotc211_org2005gmd_MD_MaintenanceInformation_PropertyType_httpwww_isotc211_org2005gconilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 33, 1)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/maintenance.xsd', 41, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}type uses Python identifier type
    __type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'type'), 'type', '__httpwww_isotc211_org2005gmd_MD_MaintenanceInformation_PropertyType_httpwww_w3_org1999xlinktype', _ImportedBinding_bindings_v1411_write__xlink.typeType, fixed=True, unicode_default='simple')
    __type._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 29, 1)
    __type._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 112, 2)
    
    type = property(__type.value, __type.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}href uses Python identifier href
    __href = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'href'), 'href', '__httpwww_isotc211_org2005gmd_MD_MaintenanceInformation_PropertyType_httpwww_w3_org1999xlinkhref', _ImportedBinding_bindings_v1411_write__xlink.hrefType)
    __href._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 42, 1)
    __href._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 113, 2)
    
    href = property(__href.value, __href.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}role uses Python identifier role
    __role = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'role'), 'role', '__httpwww_isotc211_org2005gmd_MD_MaintenanceInformation_PropertyType_httpwww_w3_org1999xlinkrole', _ImportedBinding_bindings_v1411_write__xlink.roleType)
    __role._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 48, 1)
    __role._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 114, 2)
    
    role = property(__role.value, __role.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}arcrole uses Python identifier arcrole
    __arcrole = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'arcrole'), 'arcrole', '__httpwww_isotc211_org2005gmd_MD_MaintenanceInformation_PropertyType_httpwww_w3_org1999xlinkarcrole', _ImportedBinding_bindings_v1411_write__xlink.arcroleType)
    __arcrole._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 56, 1)
    __arcrole._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 115, 2)
    
    arcrole = property(__arcrole.value, __arcrole.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}title uses Python identifier title
    __title = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'title'), 'title', '__httpwww_isotc211_org2005gmd_MD_MaintenanceInformation_PropertyType_httpwww_w3_org1999xlinktitle', _ImportedBinding_bindings_v1411_write__xlink.titleAttrType)
    __title._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 64, 1)
    __title._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 116, 2)
    
    title = property(__title.value, __title.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}show uses Python identifier show
    __show = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'show'), 'show', '__httpwww_isotc211_org2005gmd_MD_MaintenanceInformation_PropertyType_httpwww_w3_org1999xlinkshow', _ImportedBinding_bindings_v1411_write__xlink.showType)
    __show._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 70, 1)
    __show._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 117, 2)
    
    show = property(__show.value, __show.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}actuate uses Python identifier actuate
    __actuate = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'actuate'), 'actuate', '__httpwww_isotc211_org2005gmd_MD_MaintenanceInformation_PropertyType_httpwww_w3_org1999xlinkactuate', _ImportedBinding_bindings_v1411_write__xlink.actuateType)
    __actuate._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 82, 1)
    __actuate._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 118, 2)
    
    actuate = property(__actuate.value, __actuate.set, None, None)

    _ElementMap.update({
        __MD_MaintenanceInformation.name() : __MD_MaintenanceInformation
    })
    _AttributeMap.update({
        __uuidref.name() : __uuidref,
        __nilReason.name() : __nilReason,
        __type.name() : __type,
        __href.name() : __href,
        __role.name() : __role,
        __arcrole.name() : __arcrole,
        __title.name() : __title,
        __show.name() : __show,
        __actuate.name() : __actuate
    })
_module_typeBindings.MD_MaintenanceInformation_PropertyType = MD_MaintenanceInformation_PropertyType
_Namespace_gmd.addCategoryObject('typeBinding', 'MD_MaintenanceInformation_PropertyType', MD_MaintenanceInformation_PropertyType)


# Complex type {http://www.isotc211.org/2005/gmd}MD_ScopeDescription_PropertyType with content type ELEMENT_ONLY
class MD_ScopeDescription_PropertyType (pyxb.binding.basis.complexTypeDefinition):
    """Complex type {http://www.isotc211.org/2005/gmd}MD_ScopeDescription_PropertyType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_ScopeDescription_PropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/maintenance.xsd', 60, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.isotc211.org/2005/gmd}MD_ScopeDescription uses Python identifier MD_ScopeDescription
    __MD_ScopeDescription = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_ScopeDescription'), 'MD_ScopeDescription', '__httpwww_isotc211_org2005gmd_MD_ScopeDescription_PropertyType_httpwww_isotc211_org2005gmdMD_ScopeDescription', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/maintenance.xsd', 58, 1), )

    
    MD_ScopeDescription = property(__MD_ScopeDescription.value, __MD_ScopeDescription.set, None, None)

    
    # Attribute {http://www.isotc211.org/2005/gco}nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gco, 'nilReason'), 'nilReason', '__httpwww_isotc211_org2005gmd_MD_ScopeDescription_PropertyType_httpwww_isotc211_org2005gconilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 33, 1)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/maintenance.xsd', 64, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    _ElementMap.update({
        __MD_ScopeDescription.name() : __MD_ScopeDescription
    })
    _AttributeMap.update({
        __nilReason.name() : __nilReason
    })
_module_typeBindings.MD_ScopeDescription_PropertyType = MD_ScopeDescription_PropertyType
_Namespace_gmd.addCategoryObject('typeBinding', 'MD_ScopeDescription_PropertyType', MD_ScopeDescription_PropertyType)


# Complex type {http://www.isotc211.org/2005/gmd}MD_MaintenanceFrequencyCode_PropertyType with content type ELEMENT_ONLY
class MD_MaintenanceFrequencyCode_PropertyType (pyxb.binding.basis.complexTypeDefinition):
    """Complex type {http://www.isotc211.org/2005/gmd}MD_MaintenanceFrequencyCode_PropertyType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_MaintenanceFrequencyCode_PropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/maintenance.xsd', 70, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.isotc211.org/2005/gmd}MD_MaintenanceFrequencyCode uses Python identifier MD_MaintenanceFrequencyCode
    __MD_MaintenanceFrequencyCode = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_MaintenanceFrequencyCode'), 'MD_MaintenanceFrequencyCode', '__httpwww_isotc211_org2005gmd_MD_MaintenanceFrequencyCode_PropertyType_httpwww_isotc211_org2005gmdMD_MaintenanceFrequencyCode', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/maintenance.xsd', 68, 1), )

    
    MD_MaintenanceFrequencyCode = property(__MD_MaintenanceFrequencyCode.value, __MD_MaintenanceFrequencyCode.set, None, None)

    
    # Attribute {http://www.isotc211.org/2005/gco}nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gco, 'nilReason'), 'nilReason', '__httpwww_isotc211_org2005gmd_MD_MaintenanceFrequencyCode_PropertyType_httpwww_isotc211_org2005gconilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 33, 1)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/maintenance.xsd', 74, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    _ElementMap.update({
        __MD_MaintenanceFrequencyCode.name() : __MD_MaintenanceFrequencyCode
    })
    _AttributeMap.update({
        __nilReason.name() : __nilReason
    })
_module_typeBindings.MD_MaintenanceFrequencyCode_PropertyType = MD_MaintenanceFrequencyCode_PropertyType
_Namespace_gmd.addCategoryObject('typeBinding', 'MD_MaintenanceFrequencyCode_PropertyType', MD_MaintenanceFrequencyCode_PropertyType)


# Complex type {http://www.isotc211.org/2005/gmd}MD_ScopeCode_PropertyType with content type ELEMENT_ONLY
class MD_ScopeCode_PropertyType (pyxb.binding.basis.complexTypeDefinition):
    """Complex type {http://www.isotc211.org/2005/gmd}MD_ScopeCode_PropertyType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_ScopeCode_PropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/maintenance.xsd', 80, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.isotc211.org/2005/gmd}MD_ScopeCode uses Python identifier MD_ScopeCode
    __MD_ScopeCode = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_ScopeCode'), 'MD_ScopeCode', '__httpwww_isotc211_org2005gmd_MD_ScopeCode_PropertyType_httpwww_isotc211_org2005gmdMD_ScopeCode', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/maintenance.xsd', 78, 1), )

    
    MD_ScopeCode = property(__MD_ScopeCode.value, __MD_ScopeCode.set, None, None)

    
    # Attribute {http://www.isotc211.org/2005/gco}nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gco, 'nilReason'), 'nilReason', '__httpwww_isotc211_org2005gmd_MD_ScopeCode_PropertyType_httpwww_isotc211_org2005gconilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 33, 1)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/maintenance.xsd', 84, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    _ElementMap.update({
        __MD_ScopeCode.name() : __MD_ScopeCode
    })
    _AttributeMap.update({
        __nilReason.name() : __nilReason
    })
_module_typeBindings.MD_ScopeCode_PropertyType = MD_ScopeCode_PropertyType
_Namespace_gmd.addCategoryObject('typeBinding', 'MD_ScopeCode_PropertyType', MD_ScopeCode_PropertyType)


# Complex type {http://www.isotc211.org/2005/gmd}DS_Aggregate_PropertyType with content type ELEMENT_ONLY
class DS_Aggregate_PropertyType (pyxb.binding.basis.complexTypeDefinition):
    """Complex type {http://www.isotc211.org/2005/gmd}DS_Aggregate_PropertyType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'DS_Aggregate_PropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataApplication.xsd', 32, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.isotc211.org/2005/gmd}AbstractDS_Aggregate uses Python identifier AbstractDS_Aggregate
    __AbstractDS_Aggregate = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'AbstractDS_Aggregate'), 'AbstractDS_Aggregate', '__httpwww_isotc211_org2005gmd_DS_Aggregate_PropertyType_httpwww_isotc211_org2005gmdAbstractDS_Aggregate', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataApplication.xsd', 30, 1), )

    
    AbstractDS_Aggregate = property(__AbstractDS_Aggregate.value, __AbstractDS_Aggregate.set, None, None)

    
    # Attribute uuidref uses Python identifier uuidref
    __uuidref = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'uuidref'), 'uuidref', '__httpwww_isotc211_org2005gmd_DS_Aggregate_PropertyType_uuidref', pyxb.binding.datatypes.string)
    __uuidref._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 30, 2)
    __uuidref._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 30, 2)
    
    uuidref = property(__uuidref.value, __uuidref.set, None, None)

    
    # Attribute {http://www.isotc211.org/2005/gco}nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gco, 'nilReason'), 'nilReason', '__httpwww_isotc211_org2005gmd_DS_Aggregate_PropertyType_httpwww_isotc211_org2005gconilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 33, 1)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataApplication.xsd', 37, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}type uses Python identifier type
    __type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'type'), 'type', '__httpwww_isotc211_org2005gmd_DS_Aggregate_PropertyType_httpwww_w3_org1999xlinktype', _ImportedBinding_bindings_v1411_write__xlink.typeType, fixed=True, unicode_default='simple')
    __type._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 29, 1)
    __type._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 112, 2)
    
    type = property(__type.value, __type.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}href uses Python identifier href
    __href = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'href'), 'href', '__httpwww_isotc211_org2005gmd_DS_Aggregate_PropertyType_httpwww_w3_org1999xlinkhref', _ImportedBinding_bindings_v1411_write__xlink.hrefType)
    __href._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 42, 1)
    __href._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 113, 2)
    
    href = property(__href.value, __href.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}role uses Python identifier role
    __role = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'role'), 'role', '__httpwww_isotc211_org2005gmd_DS_Aggregate_PropertyType_httpwww_w3_org1999xlinkrole', _ImportedBinding_bindings_v1411_write__xlink.roleType)
    __role._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 48, 1)
    __role._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 114, 2)
    
    role = property(__role.value, __role.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}arcrole uses Python identifier arcrole
    __arcrole = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'arcrole'), 'arcrole', '__httpwww_isotc211_org2005gmd_DS_Aggregate_PropertyType_httpwww_w3_org1999xlinkarcrole', _ImportedBinding_bindings_v1411_write__xlink.arcroleType)
    __arcrole._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 56, 1)
    __arcrole._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 115, 2)
    
    arcrole = property(__arcrole.value, __arcrole.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}title uses Python identifier title
    __title = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'title'), 'title', '__httpwww_isotc211_org2005gmd_DS_Aggregate_PropertyType_httpwww_w3_org1999xlinktitle', _ImportedBinding_bindings_v1411_write__xlink.titleAttrType)
    __title._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 64, 1)
    __title._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 116, 2)
    
    title = property(__title.value, __title.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}show uses Python identifier show
    __show = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'show'), 'show', '__httpwww_isotc211_org2005gmd_DS_Aggregate_PropertyType_httpwww_w3_org1999xlinkshow', _ImportedBinding_bindings_v1411_write__xlink.showType)
    __show._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 70, 1)
    __show._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 117, 2)
    
    show = property(__show.value, __show.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}actuate uses Python identifier actuate
    __actuate = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'actuate'), 'actuate', '__httpwww_isotc211_org2005gmd_DS_Aggregate_PropertyType_httpwww_w3_org1999xlinkactuate', _ImportedBinding_bindings_v1411_write__xlink.actuateType)
    __actuate._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 82, 1)
    __actuate._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 118, 2)
    
    actuate = property(__actuate.value, __actuate.set, None, None)

    _ElementMap.update({
        __AbstractDS_Aggregate.name() : __AbstractDS_Aggregate
    })
    _AttributeMap.update({
        __uuidref.name() : __uuidref,
        __nilReason.name() : __nilReason,
        __type.name() : __type,
        __href.name() : __href,
        __role.name() : __role,
        __arcrole.name() : __arcrole,
        __title.name() : __title,
        __show.name() : __show,
        __actuate.name() : __actuate
    })
_module_typeBindings.DS_Aggregate_PropertyType = DS_Aggregate_PropertyType
_Namespace_gmd.addCategoryObject('typeBinding', 'DS_Aggregate_PropertyType', DS_Aggregate_PropertyType)


# Complex type {http://www.isotc211.org/2005/gmd}DS_DataSet_PropertyType with content type ELEMENT_ONLY
class DS_DataSet_PropertyType (pyxb.binding.basis.complexTypeDefinition):
    """Complex type {http://www.isotc211.org/2005/gmd}DS_DataSet_PropertyType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'DS_DataSet_PropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataApplication.xsd', 56, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.isotc211.org/2005/gmd}DS_DataSet uses Python identifier DS_DataSet
    __DS_DataSet = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'DS_DataSet'), 'DS_DataSet', '__httpwww_isotc211_org2005gmd_DS_DataSet_PropertyType_httpwww_isotc211_org2005gmdDS_DataSet', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataApplication.xsd', 54, 1), )

    
    DS_DataSet = property(__DS_DataSet.value, __DS_DataSet.set, None, None)

    
    # Attribute uuidref uses Python identifier uuidref
    __uuidref = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'uuidref'), 'uuidref', '__httpwww_isotc211_org2005gmd_DS_DataSet_PropertyType_uuidref', pyxb.binding.datatypes.string)
    __uuidref._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 30, 2)
    __uuidref._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 30, 2)
    
    uuidref = property(__uuidref.value, __uuidref.set, None, None)

    
    # Attribute {http://www.isotc211.org/2005/gco}nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gco, 'nilReason'), 'nilReason', '__httpwww_isotc211_org2005gmd_DS_DataSet_PropertyType_httpwww_isotc211_org2005gconilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 33, 1)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataApplication.xsd', 61, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}type uses Python identifier type
    __type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'type'), 'type', '__httpwww_isotc211_org2005gmd_DS_DataSet_PropertyType_httpwww_w3_org1999xlinktype', _ImportedBinding_bindings_v1411_write__xlink.typeType, fixed=True, unicode_default='simple')
    __type._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 29, 1)
    __type._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 112, 2)
    
    type = property(__type.value, __type.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}href uses Python identifier href
    __href = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'href'), 'href', '__httpwww_isotc211_org2005gmd_DS_DataSet_PropertyType_httpwww_w3_org1999xlinkhref', _ImportedBinding_bindings_v1411_write__xlink.hrefType)
    __href._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 42, 1)
    __href._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 113, 2)
    
    href = property(__href.value, __href.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}role uses Python identifier role
    __role = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'role'), 'role', '__httpwww_isotc211_org2005gmd_DS_DataSet_PropertyType_httpwww_w3_org1999xlinkrole', _ImportedBinding_bindings_v1411_write__xlink.roleType)
    __role._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 48, 1)
    __role._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 114, 2)
    
    role = property(__role.value, __role.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}arcrole uses Python identifier arcrole
    __arcrole = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'arcrole'), 'arcrole', '__httpwww_isotc211_org2005gmd_DS_DataSet_PropertyType_httpwww_w3_org1999xlinkarcrole', _ImportedBinding_bindings_v1411_write__xlink.arcroleType)
    __arcrole._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 56, 1)
    __arcrole._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 115, 2)
    
    arcrole = property(__arcrole.value, __arcrole.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}title uses Python identifier title
    __title = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'title'), 'title', '__httpwww_isotc211_org2005gmd_DS_DataSet_PropertyType_httpwww_w3_org1999xlinktitle', _ImportedBinding_bindings_v1411_write__xlink.titleAttrType)
    __title._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 64, 1)
    __title._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 116, 2)
    
    title = property(__title.value, __title.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}show uses Python identifier show
    __show = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'show'), 'show', '__httpwww_isotc211_org2005gmd_DS_DataSet_PropertyType_httpwww_w3_org1999xlinkshow', _ImportedBinding_bindings_v1411_write__xlink.showType)
    __show._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 70, 1)
    __show._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 117, 2)
    
    show = property(__show.value, __show.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}actuate uses Python identifier actuate
    __actuate = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'actuate'), 'actuate', '__httpwww_isotc211_org2005gmd_DS_DataSet_PropertyType_httpwww_w3_org1999xlinkactuate', _ImportedBinding_bindings_v1411_write__xlink.actuateType)
    __actuate._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 82, 1)
    __actuate._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 118, 2)
    
    actuate = property(__actuate.value, __actuate.set, None, None)

    _ElementMap.update({
        __DS_DataSet.name() : __DS_DataSet
    })
    _AttributeMap.update({
        __uuidref.name() : __uuidref,
        __nilReason.name() : __nilReason,
        __type.name() : __type,
        __href.name() : __href,
        __role.name() : __role,
        __arcrole.name() : __arcrole,
        __title.name() : __title,
        __show.name() : __show,
        __actuate.name() : __actuate
    })
_module_typeBindings.DS_DataSet_PropertyType = DS_DataSet_PropertyType
_Namespace_gmd.addCategoryObject('typeBinding', 'DS_DataSet_PropertyType', DS_DataSet_PropertyType)


# Complex type {http://www.isotc211.org/2005/gmd}DS_OtherAggregate_Type with content type ELEMENT_ONLY
class DS_OtherAggregate_Type (AbstractDS_Aggregate_Type):
    """Complex type {http://www.isotc211.org/2005/gmd}DS_OtherAggregate_Type with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'DS_OtherAggregate_Type')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataApplication.xsd', 64, 1)
    _ElementMap = AbstractDS_Aggregate_Type._ElementMap.copy()
    _AttributeMap = AbstractDS_Aggregate_Type._AttributeMap.copy()
    # Base type is AbstractDS_Aggregate_Type
    
    # Element composedOf ({http://www.isotc211.org/2005/gmd}composedOf) inherited from {http://www.isotc211.org/2005/gmd}AbstractDS_Aggregate_Type
    
    # Element seriesMetadata ({http://www.isotc211.org/2005/gmd}seriesMetadata) inherited from {http://www.isotc211.org/2005/gmd}AbstractDS_Aggregate_Type
    
    # Element subset ({http://www.isotc211.org/2005/gmd}subset) inherited from {http://www.isotc211.org/2005/gmd}AbstractDS_Aggregate_Type
    
    # Element superset ({http://www.isotc211.org/2005/gmd}superset) inherited from {http://www.isotc211.org/2005/gmd}AbstractDS_Aggregate_Type
    
    # Attribute id inherited from {http://www.isotc211.org/2005/gco}AbstractObject_Type
    
    # Attribute uuid inherited from {http://www.isotc211.org/2005/gco}AbstractObject_Type
    _ElementMap.update({
        
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.DS_OtherAggregate_Type = DS_OtherAggregate_Type
_Namespace_gmd.addCategoryObject('typeBinding', 'DS_OtherAggregate_Type', DS_OtherAggregate_Type)


# Complex type {http://www.isotc211.org/2005/gmd}DS_OtherAggregate_PropertyType with content type ELEMENT_ONLY
class DS_OtherAggregate_PropertyType (pyxb.binding.basis.complexTypeDefinition):
    """Complex type {http://www.isotc211.org/2005/gmd}DS_OtherAggregate_PropertyType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'DS_OtherAggregate_PropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataApplication.xsd', 72, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.isotc211.org/2005/gmd}DS_OtherAggregate uses Python identifier DS_OtherAggregate
    __DS_OtherAggregate = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'DS_OtherAggregate'), 'DS_OtherAggregate', '__httpwww_isotc211_org2005gmd_DS_OtherAggregate_PropertyType_httpwww_isotc211_org2005gmdDS_OtherAggregate', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataApplication.xsd', 70, 1), )

    
    DS_OtherAggregate = property(__DS_OtherAggregate.value, __DS_OtherAggregate.set, None, None)

    
    # Attribute uuidref uses Python identifier uuidref
    __uuidref = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'uuidref'), 'uuidref', '__httpwww_isotc211_org2005gmd_DS_OtherAggregate_PropertyType_uuidref', pyxb.binding.datatypes.string)
    __uuidref._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 30, 2)
    __uuidref._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 30, 2)
    
    uuidref = property(__uuidref.value, __uuidref.set, None, None)

    
    # Attribute {http://www.isotc211.org/2005/gco}nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gco, 'nilReason'), 'nilReason', '__httpwww_isotc211_org2005gmd_DS_OtherAggregate_PropertyType_httpwww_isotc211_org2005gconilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 33, 1)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataApplication.xsd', 77, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}type uses Python identifier type
    __type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'type'), 'type', '__httpwww_isotc211_org2005gmd_DS_OtherAggregate_PropertyType_httpwww_w3_org1999xlinktype', _ImportedBinding_bindings_v1411_write__xlink.typeType, fixed=True, unicode_default='simple')
    __type._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 29, 1)
    __type._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 112, 2)
    
    type = property(__type.value, __type.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}href uses Python identifier href
    __href = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'href'), 'href', '__httpwww_isotc211_org2005gmd_DS_OtherAggregate_PropertyType_httpwww_w3_org1999xlinkhref', _ImportedBinding_bindings_v1411_write__xlink.hrefType)
    __href._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 42, 1)
    __href._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 113, 2)
    
    href = property(__href.value, __href.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}role uses Python identifier role
    __role = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'role'), 'role', '__httpwww_isotc211_org2005gmd_DS_OtherAggregate_PropertyType_httpwww_w3_org1999xlinkrole', _ImportedBinding_bindings_v1411_write__xlink.roleType)
    __role._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 48, 1)
    __role._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 114, 2)
    
    role = property(__role.value, __role.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}arcrole uses Python identifier arcrole
    __arcrole = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'arcrole'), 'arcrole', '__httpwww_isotc211_org2005gmd_DS_OtherAggregate_PropertyType_httpwww_w3_org1999xlinkarcrole', _ImportedBinding_bindings_v1411_write__xlink.arcroleType)
    __arcrole._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 56, 1)
    __arcrole._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 115, 2)
    
    arcrole = property(__arcrole.value, __arcrole.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}title uses Python identifier title
    __title = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'title'), 'title', '__httpwww_isotc211_org2005gmd_DS_OtherAggregate_PropertyType_httpwww_w3_org1999xlinktitle', _ImportedBinding_bindings_v1411_write__xlink.titleAttrType)
    __title._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 64, 1)
    __title._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 116, 2)
    
    title = property(__title.value, __title.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}show uses Python identifier show
    __show = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'show'), 'show', '__httpwww_isotc211_org2005gmd_DS_OtherAggregate_PropertyType_httpwww_w3_org1999xlinkshow', _ImportedBinding_bindings_v1411_write__xlink.showType)
    __show._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 70, 1)
    __show._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 117, 2)
    
    show = property(__show.value, __show.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}actuate uses Python identifier actuate
    __actuate = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'actuate'), 'actuate', '__httpwww_isotc211_org2005gmd_DS_OtherAggregate_PropertyType_httpwww_w3_org1999xlinkactuate', _ImportedBinding_bindings_v1411_write__xlink.actuateType)
    __actuate._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 82, 1)
    __actuate._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 118, 2)
    
    actuate = property(__actuate.value, __actuate.set, None, None)

    _ElementMap.update({
        __DS_OtherAggregate.name() : __DS_OtherAggregate
    })
    _AttributeMap.update({
        __uuidref.name() : __uuidref,
        __nilReason.name() : __nilReason,
        __type.name() : __type,
        __href.name() : __href,
        __role.name() : __role,
        __arcrole.name() : __arcrole,
        __title.name() : __title,
        __show.name() : __show,
        __actuate.name() : __actuate
    })
_module_typeBindings.DS_OtherAggregate_PropertyType = DS_OtherAggregate_PropertyType
_Namespace_gmd.addCategoryObject('typeBinding', 'DS_OtherAggregate_PropertyType', DS_OtherAggregate_PropertyType)


# Complex type {http://www.isotc211.org/2005/gmd}DS_Series_Type with content type ELEMENT_ONLY
class DS_Series_Type (AbstractDS_Aggregate_Type):
    """Complex type {http://www.isotc211.org/2005/gmd}DS_Series_Type with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'DS_Series_Type')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataApplication.xsd', 80, 1)
    _ElementMap = AbstractDS_Aggregate_Type._ElementMap.copy()
    _AttributeMap = AbstractDS_Aggregate_Type._AttributeMap.copy()
    # Base type is AbstractDS_Aggregate_Type
    
    # Element composedOf ({http://www.isotc211.org/2005/gmd}composedOf) inherited from {http://www.isotc211.org/2005/gmd}AbstractDS_Aggregate_Type
    
    # Element seriesMetadata ({http://www.isotc211.org/2005/gmd}seriesMetadata) inherited from {http://www.isotc211.org/2005/gmd}AbstractDS_Aggregate_Type
    
    # Element subset ({http://www.isotc211.org/2005/gmd}subset) inherited from {http://www.isotc211.org/2005/gmd}AbstractDS_Aggregate_Type
    
    # Element superset ({http://www.isotc211.org/2005/gmd}superset) inherited from {http://www.isotc211.org/2005/gmd}AbstractDS_Aggregate_Type
    
    # Attribute id inherited from {http://www.isotc211.org/2005/gco}AbstractObject_Type
    
    # Attribute uuid inherited from {http://www.isotc211.org/2005/gco}AbstractObject_Type
    _ElementMap.update({
        
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.DS_Series_Type = DS_Series_Type
_Namespace_gmd.addCategoryObject('typeBinding', 'DS_Series_Type', DS_Series_Type)


# Complex type {http://www.isotc211.org/2005/gmd}DS_Series_PropertyType with content type ELEMENT_ONLY
class DS_Series_PropertyType (pyxb.binding.basis.complexTypeDefinition):
    """Complex type {http://www.isotc211.org/2005/gmd}DS_Series_PropertyType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'DS_Series_PropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataApplication.xsd', 88, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.isotc211.org/2005/gmd}DS_Series uses Python identifier DS_Series
    __DS_Series = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'DS_Series'), 'DS_Series', '__httpwww_isotc211_org2005gmd_DS_Series_PropertyType_httpwww_isotc211_org2005gmdDS_Series', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataApplication.xsd', 86, 1), )

    
    DS_Series = property(__DS_Series.value, __DS_Series.set, None, None)

    
    # Attribute uuidref uses Python identifier uuidref
    __uuidref = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'uuidref'), 'uuidref', '__httpwww_isotc211_org2005gmd_DS_Series_PropertyType_uuidref', pyxb.binding.datatypes.string)
    __uuidref._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 30, 2)
    __uuidref._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 30, 2)
    
    uuidref = property(__uuidref.value, __uuidref.set, None, None)

    
    # Attribute {http://www.isotc211.org/2005/gco}nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gco, 'nilReason'), 'nilReason', '__httpwww_isotc211_org2005gmd_DS_Series_PropertyType_httpwww_isotc211_org2005gconilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 33, 1)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataApplication.xsd', 93, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}type uses Python identifier type
    __type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'type'), 'type', '__httpwww_isotc211_org2005gmd_DS_Series_PropertyType_httpwww_w3_org1999xlinktype', _ImportedBinding_bindings_v1411_write__xlink.typeType, fixed=True, unicode_default='simple')
    __type._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 29, 1)
    __type._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 112, 2)
    
    type = property(__type.value, __type.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}href uses Python identifier href
    __href = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'href'), 'href', '__httpwww_isotc211_org2005gmd_DS_Series_PropertyType_httpwww_w3_org1999xlinkhref', _ImportedBinding_bindings_v1411_write__xlink.hrefType)
    __href._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 42, 1)
    __href._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 113, 2)
    
    href = property(__href.value, __href.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}role uses Python identifier role
    __role = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'role'), 'role', '__httpwww_isotc211_org2005gmd_DS_Series_PropertyType_httpwww_w3_org1999xlinkrole', _ImportedBinding_bindings_v1411_write__xlink.roleType)
    __role._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 48, 1)
    __role._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 114, 2)
    
    role = property(__role.value, __role.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}arcrole uses Python identifier arcrole
    __arcrole = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'arcrole'), 'arcrole', '__httpwww_isotc211_org2005gmd_DS_Series_PropertyType_httpwww_w3_org1999xlinkarcrole', _ImportedBinding_bindings_v1411_write__xlink.arcroleType)
    __arcrole._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 56, 1)
    __arcrole._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 115, 2)
    
    arcrole = property(__arcrole.value, __arcrole.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}title uses Python identifier title
    __title = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'title'), 'title', '__httpwww_isotc211_org2005gmd_DS_Series_PropertyType_httpwww_w3_org1999xlinktitle', _ImportedBinding_bindings_v1411_write__xlink.titleAttrType)
    __title._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 64, 1)
    __title._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 116, 2)
    
    title = property(__title.value, __title.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}show uses Python identifier show
    __show = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'show'), 'show', '__httpwww_isotc211_org2005gmd_DS_Series_PropertyType_httpwww_w3_org1999xlinkshow', _ImportedBinding_bindings_v1411_write__xlink.showType)
    __show._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 70, 1)
    __show._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 117, 2)
    
    show = property(__show.value, __show.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}actuate uses Python identifier actuate
    __actuate = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'actuate'), 'actuate', '__httpwww_isotc211_org2005gmd_DS_Series_PropertyType_httpwww_w3_org1999xlinkactuate', _ImportedBinding_bindings_v1411_write__xlink.actuateType)
    __actuate._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 82, 1)
    __actuate._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 118, 2)
    
    actuate = property(__actuate.value, __actuate.set, None, None)

    _ElementMap.update({
        __DS_Series.name() : __DS_Series
    })
    _AttributeMap.update({
        __uuidref.name() : __uuidref,
        __nilReason.name() : __nilReason,
        __type.name() : __type,
        __href.name() : __href,
        __role.name() : __role,
        __arcrole.name() : __arcrole,
        __title.name() : __title,
        __show.name() : __show,
        __actuate.name() : __actuate
    })
_module_typeBindings.DS_Series_PropertyType = DS_Series_PropertyType
_Namespace_gmd.addCategoryObject('typeBinding', 'DS_Series_PropertyType', DS_Series_PropertyType)


# Complex type {http://www.isotc211.org/2005/gmd}DS_Initiative_Type with content type ELEMENT_ONLY
class DS_Initiative_Type (AbstractDS_Aggregate_Type):
    """Complex type {http://www.isotc211.org/2005/gmd}DS_Initiative_Type with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'DS_Initiative_Type')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataApplication.xsd', 96, 1)
    _ElementMap = AbstractDS_Aggregate_Type._ElementMap.copy()
    _AttributeMap = AbstractDS_Aggregate_Type._AttributeMap.copy()
    # Base type is AbstractDS_Aggregate_Type
    
    # Element composedOf ({http://www.isotc211.org/2005/gmd}composedOf) inherited from {http://www.isotc211.org/2005/gmd}AbstractDS_Aggregate_Type
    
    # Element seriesMetadata ({http://www.isotc211.org/2005/gmd}seriesMetadata) inherited from {http://www.isotc211.org/2005/gmd}AbstractDS_Aggregate_Type
    
    # Element subset ({http://www.isotc211.org/2005/gmd}subset) inherited from {http://www.isotc211.org/2005/gmd}AbstractDS_Aggregate_Type
    
    # Element superset ({http://www.isotc211.org/2005/gmd}superset) inherited from {http://www.isotc211.org/2005/gmd}AbstractDS_Aggregate_Type
    
    # Attribute id inherited from {http://www.isotc211.org/2005/gco}AbstractObject_Type
    
    # Attribute uuid inherited from {http://www.isotc211.org/2005/gco}AbstractObject_Type
    _ElementMap.update({
        
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.DS_Initiative_Type = DS_Initiative_Type
_Namespace_gmd.addCategoryObject('typeBinding', 'DS_Initiative_Type', DS_Initiative_Type)


# Complex type {http://www.isotc211.org/2005/gmd}DS_Initiative_PropertyType with content type ELEMENT_ONLY
class DS_Initiative_PropertyType (pyxb.binding.basis.complexTypeDefinition):
    """Complex type {http://www.isotc211.org/2005/gmd}DS_Initiative_PropertyType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'DS_Initiative_PropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataApplication.xsd', 104, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.isotc211.org/2005/gmd}DS_Initiative uses Python identifier DS_Initiative
    __DS_Initiative = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'DS_Initiative'), 'DS_Initiative', '__httpwww_isotc211_org2005gmd_DS_Initiative_PropertyType_httpwww_isotc211_org2005gmdDS_Initiative', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataApplication.xsd', 102, 1), )

    
    DS_Initiative = property(__DS_Initiative.value, __DS_Initiative.set, None, None)

    
    # Attribute uuidref uses Python identifier uuidref
    __uuidref = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'uuidref'), 'uuidref', '__httpwww_isotc211_org2005gmd_DS_Initiative_PropertyType_uuidref', pyxb.binding.datatypes.string)
    __uuidref._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 30, 2)
    __uuidref._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 30, 2)
    
    uuidref = property(__uuidref.value, __uuidref.set, None, None)

    
    # Attribute {http://www.isotc211.org/2005/gco}nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gco, 'nilReason'), 'nilReason', '__httpwww_isotc211_org2005gmd_DS_Initiative_PropertyType_httpwww_isotc211_org2005gconilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 33, 1)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataApplication.xsd', 109, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}type uses Python identifier type
    __type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'type'), 'type', '__httpwww_isotc211_org2005gmd_DS_Initiative_PropertyType_httpwww_w3_org1999xlinktype', _ImportedBinding_bindings_v1411_write__xlink.typeType, fixed=True, unicode_default='simple')
    __type._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 29, 1)
    __type._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 112, 2)
    
    type = property(__type.value, __type.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}href uses Python identifier href
    __href = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'href'), 'href', '__httpwww_isotc211_org2005gmd_DS_Initiative_PropertyType_httpwww_w3_org1999xlinkhref', _ImportedBinding_bindings_v1411_write__xlink.hrefType)
    __href._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 42, 1)
    __href._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 113, 2)
    
    href = property(__href.value, __href.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}role uses Python identifier role
    __role = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'role'), 'role', '__httpwww_isotc211_org2005gmd_DS_Initiative_PropertyType_httpwww_w3_org1999xlinkrole', _ImportedBinding_bindings_v1411_write__xlink.roleType)
    __role._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 48, 1)
    __role._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 114, 2)
    
    role = property(__role.value, __role.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}arcrole uses Python identifier arcrole
    __arcrole = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'arcrole'), 'arcrole', '__httpwww_isotc211_org2005gmd_DS_Initiative_PropertyType_httpwww_w3_org1999xlinkarcrole', _ImportedBinding_bindings_v1411_write__xlink.arcroleType)
    __arcrole._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 56, 1)
    __arcrole._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 115, 2)
    
    arcrole = property(__arcrole.value, __arcrole.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}title uses Python identifier title
    __title = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'title'), 'title', '__httpwww_isotc211_org2005gmd_DS_Initiative_PropertyType_httpwww_w3_org1999xlinktitle', _ImportedBinding_bindings_v1411_write__xlink.titleAttrType)
    __title._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 64, 1)
    __title._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 116, 2)
    
    title = property(__title.value, __title.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}show uses Python identifier show
    __show = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'show'), 'show', '__httpwww_isotc211_org2005gmd_DS_Initiative_PropertyType_httpwww_w3_org1999xlinkshow', _ImportedBinding_bindings_v1411_write__xlink.showType)
    __show._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 70, 1)
    __show._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 117, 2)
    
    show = property(__show.value, __show.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}actuate uses Python identifier actuate
    __actuate = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'actuate'), 'actuate', '__httpwww_isotc211_org2005gmd_DS_Initiative_PropertyType_httpwww_w3_org1999xlinkactuate', _ImportedBinding_bindings_v1411_write__xlink.actuateType)
    __actuate._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 82, 1)
    __actuate._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 118, 2)
    
    actuate = property(__actuate.value, __actuate.set, None, None)

    _ElementMap.update({
        __DS_Initiative.name() : __DS_Initiative
    })
    _AttributeMap.update({
        __uuidref.name() : __uuidref,
        __nilReason.name() : __nilReason,
        __type.name() : __type,
        __href.name() : __href,
        __role.name() : __role,
        __arcrole.name() : __arcrole,
        __title.name() : __title,
        __show.name() : __show,
        __actuate.name() : __actuate
    })
_module_typeBindings.DS_Initiative_PropertyType = DS_Initiative_PropertyType
_Namespace_gmd.addCategoryObject('typeBinding', 'DS_Initiative_PropertyType', DS_Initiative_PropertyType)


# Complex type {http://www.isotc211.org/2005/gmd}DS_Platform_PropertyType with content type ELEMENT_ONLY
class DS_Platform_PropertyType (pyxb.binding.basis.complexTypeDefinition):
    """Complex type {http://www.isotc211.org/2005/gmd}DS_Platform_PropertyType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'DS_Platform_PropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataApplication.xsd', 120, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.isotc211.org/2005/gmd}DS_Platform uses Python identifier DS_Platform
    __DS_Platform = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'DS_Platform'), 'DS_Platform', '__httpwww_isotc211_org2005gmd_DS_Platform_PropertyType_httpwww_isotc211_org2005gmdDS_Platform', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataApplication.xsd', 118, 1), )

    
    DS_Platform = property(__DS_Platform.value, __DS_Platform.set, None, None)

    
    # Attribute uuidref uses Python identifier uuidref
    __uuidref = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'uuidref'), 'uuidref', '__httpwww_isotc211_org2005gmd_DS_Platform_PropertyType_uuidref', pyxb.binding.datatypes.string)
    __uuidref._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 30, 2)
    __uuidref._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 30, 2)
    
    uuidref = property(__uuidref.value, __uuidref.set, None, None)

    
    # Attribute {http://www.isotc211.org/2005/gco}nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gco, 'nilReason'), 'nilReason', '__httpwww_isotc211_org2005gmd_DS_Platform_PropertyType_httpwww_isotc211_org2005gconilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 33, 1)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataApplication.xsd', 125, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}type uses Python identifier type
    __type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'type'), 'type', '__httpwww_isotc211_org2005gmd_DS_Platform_PropertyType_httpwww_w3_org1999xlinktype', _ImportedBinding_bindings_v1411_write__xlink.typeType, fixed=True, unicode_default='simple')
    __type._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 29, 1)
    __type._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 112, 2)
    
    type = property(__type.value, __type.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}href uses Python identifier href
    __href = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'href'), 'href', '__httpwww_isotc211_org2005gmd_DS_Platform_PropertyType_httpwww_w3_org1999xlinkhref', _ImportedBinding_bindings_v1411_write__xlink.hrefType)
    __href._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 42, 1)
    __href._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 113, 2)
    
    href = property(__href.value, __href.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}role uses Python identifier role
    __role = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'role'), 'role', '__httpwww_isotc211_org2005gmd_DS_Platform_PropertyType_httpwww_w3_org1999xlinkrole', _ImportedBinding_bindings_v1411_write__xlink.roleType)
    __role._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 48, 1)
    __role._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 114, 2)
    
    role = property(__role.value, __role.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}arcrole uses Python identifier arcrole
    __arcrole = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'arcrole'), 'arcrole', '__httpwww_isotc211_org2005gmd_DS_Platform_PropertyType_httpwww_w3_org1999xlinkarcrole', _ImportedBinding_bindings_v1411_write__xlink.arcroleType)
    __arcrole._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 56, 1)
    __arcrole._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 115, 2)
    
    arcrole = property(__arcrole.value, __arcrole.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}title uses Python identifier title
    __title = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'title'), 'title', '__httpwww_isotc211_org2005gmd_DS_Platform_PropertyType_httpwww_w3_org1999xlinktitle', _ImportedBinding_bindings_v1411_write__xlink.titleAttrType)
    __title._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 64, 1)
    __title._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 116, 2)
    
    title = property(__title.value, __title.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}show uses Python identifier show
    __show = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'show'), 'show', '__httpwww_isotc211_org2005gmd_DS_Platform_PropertyType_httpwww_w3_org1999xlinkshow', _ImportedBinding_bindings_v1411_write__xlink.showType)
    __show._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 70, 1)
    __show._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 117, 2)
    
    show = property(__show.value, __show.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}actuate uses Python identifier actuate
    __actuate = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'actuate'), 'actuate', '__httpwww_isotc211_org2005gmd_DS_Platform_PropertyType_httpwww_w3_org1999xlinkactuate', _ImportedBinding_bindings_v1411_write__xlink.actuateType)
    __actuate._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 82, 1)
    __actuate._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 118, 2)
    
    actuate = property(__actuate.value, __actuate.set, None, None)

    _ElementMap.update({
        __DS_Platform.name() : __DS_Platform
    })
    _AttributeMap.update({
        __uuidref.name() : __uuidref,
        __nilReason.name() : __nilReason,
        __type.name() : __type,
        __href.name() : __href,
        __role.name() : __role,
        __arcrole.name() : __arcrole,
        __title.name() : __title,
        __show.name() : __show,
        __actuate.name() : __actuate
    })
_module_typeBindings.DS_Platform_PropertyType = DS_Platform_PropertyType
_Namespace_gmd.addCategoryObject('typeBinding', 'DS_Platform_PropertyType', DS_Platform_PropertyType)


# Complex type {http://www.isotc211.org/2005/gmd}DS_Sensor_PropertyType with content type ELEMENT_ONLY
class DS_Sensor_PropertyType (pyxb.binding.basis.complexTypeDefinition):
    """Complex type {http://www.isotc211.org/2005/gmd}DS_Sensor_PropertyType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'DS_Sensor_PropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataApplication.xsd', 136, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.isotc211.org/2005/gmd}DS_Sensor uses Python identifier DS_Sensor
    __DS_Sensor = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'DS_Sensor'), 'DS_Sensor', '__httpwww_isotc211_org2005gmd_DS_Sensor_PropertyType_httpwww_isotc211_org2005gmdDS_Sensor', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataApplication.xsd', 134, 1), )

    
    DS_Sensor = property(__DS_Sensor.value, __DS_Sensor.set, None, None)

    
    # Attribute uuidref uses Python identifier uuidref
    __uuidref = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'uuidref'), 'uuidref', '__httpwww_isotc211_org2005gmd_DS_Sensor_PropertyType_uuidref', pyxb.binding.datatypes.string)
    __uuidref._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 30, 2)
    __uuidref._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 30, 2)
    
    uuidref = property(__uuidref.value, __uuidref.set, None, None)

    
    # Attribute {http://www.isotc211.org/2005/gco}nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gco, 'nilReason'), 'nilReason', '__httpwww_isotc211_org2005gmd_DS_Sensor_PropertyType_httpwww_isotc211_org2005gconilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 33, 1)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataApplication.xsd', 141, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}type uses Python identifier type
    __type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'type'), 'type', '__httpwww_isotc211_org2005gmd_DS_Sensor_PropertyType_httpwww_w3_org1999xlinktype', _ImportedBinding_bindings_v1411_write__xlink.typeType, fixed=True, unicode_default='simple')
    __type._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 29, 1)
    __type._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 112, 2)
    
    type = property(__type.value, __type.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}href uses Python identifier href
    __href = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'href'), 'href', '__httpwww_isotc211_org2005gmd_DS_Sensor_PropertyType_httpwww_w3_org1999xlinkhref', _ImportedBinding_bindings_v1411_write__xlink.hrefType)
    __href._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 42, 1)
    __href._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 113, 2)
    
    href = property(__href.value, __href.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}role uses Python identifier role
    __role = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'role'), 'role', '__httpwww_isotc211_org2005gmd_DS_Sensor_PropertyType_httpwww_w3_org1999xlinkrole', _ImportedBinding_bindings_v1411_write__xlink.roleType)
    __role._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 48, 1)
    __role._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 114, 2)
    
    role = property(__role.value, __role.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}arcrole uses Python identifier arcrole
    __arcrole = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'arcrole'), 'arcrole', '__httpwww_isotc211_org2005gmd_DS_Sensor_PropertyType_httpwww_w3_org1999xlinkarcrole', _ImportedBinding_bindings_v1411_write__xlink.arcroleType)
    __arcrole._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 56, 1)
    __arcrole._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 115, 2)
    
    arcrole = property(__arcrole.value, __arcrole.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}title uses Python identifier title
    __title = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'title'), 'title', '__httpwww_isotc211_org2005gmd_DS_Sensor_PropertyType_httpwww_w3_org1999xlinktitle', _ImportedBinding_bindings_v1411_write__xlink.titleAttrType)
    __title._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 64, 1)
    __title._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 116, 2)
    
    title = property(__title.value, __title.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}show uses Python identifier show
    __show = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'show'), 'show', '__httpwww_isotc211_org2005gmd_DS_Sensor_PropertyType_httpwww_w3_org1999xlinkshow', _ImportedBinding_bindings_v1411_write__xlink.showType)
    __show._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 70, 1)
    __show._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 117, 2)
    
    show = property(__show.value, __show.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}actuate uses Python identifier actuate
    __actuate = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'actuate'), 'actuate', '__httpwww_isotc211_org2005gmd_DS_Sensor_PropertyType_httpwww_w3_org1999xlinkactuate', _ImportedBinding_bindings_v1411_write__xlink.actuateType)
    __actuate._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 82, 1)
    __actuate._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 118, 2)
    
    actuate = property(__actuate.value, __actuate.set, None, None)

    _ElementMap.update({
        __DS_Sensor.name() : __DS_Sensor
    })
    _AttributeMap.update({
        __uuidref.name() : __uuidref,
        __nilReason.name() : __nilReason,
        __type.name() : __type,
        __href.name() : __href,
        __role.name() : __role,
        __arcrole.name() : __arcrole,
        __title.name() : __title,
        __show.name() : __show,
        __actuate.name() : __actuate
    })
_module_typeBindings.DS_Sensor_PropertyType = DS_Sensor_PropertyType
_Namespace_gmd.addCategoryObject('typeBinding', 'DS_Sensor_PropertyType', DS_Sensor_PropertyType)


# Complex type {http://www.isotc211.org/2005/gmd}DS_ProductionSeries_PropertyType with content type ELEMENT_ONLY
class DS_ProductionSeries_PropertyType (pyxb.binding.basis.complexTypeDefinition):
    """Complex type {http://www.isotc211.org/2005/gmd}DS_ProductionSeries_PropertyType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'DS_ProductionSeries_PropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataApplication.xsd', 152, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.isotc211.org/2005/gmd}DS_ProductionSeries uses Python identifier DS_ProductionSeries
    __DS_ProductionSeries = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'DS_ProductionSeries'), 'DS_ProductionSeries', '__httpwww_isotc211_org2005gmd_DS_ProductionSeries_PropertyType_httpwww_isotc211_org2005gmdDS_ProductionSeries', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataApplication.xsd', 150, 1), )

    
    DS_ProductionSeries = property(__DS_ProductionSeries.value, __DS_ProductionSeries.set, None, None)

    
    # Attribute uuidref uses Python identifier uuidref
    __uuidref = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'uuidref'), 'uuidref', '__httpwww_isotc211_org2005gmd_DS_ProductionSeries_PropertyType_uuidref', pyxb.binding.datatypes.string)
    __uuidref._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 30, 2)
    __uuidref._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 30, 2)
    
    uuidref = property(__uuidref.value, __uuidref.set, None, None)

    
    # Attribute {http://www.isotc211.org/2005/gco}nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gco, 'nilReason'), 'nilReason', '__httpwww_isotc211_org2005gmd_DS_ProductionSeries_PropertyType_httpwww_isotc211_org2005gconilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 33, 1)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataApplication.xsd', 157, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}type uses Python identifier type
    __type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'type'), 'type', '__httpwww_isotc211_org2005gmd_DS_ProductionSeries_PropertyType_httpwww_w3_org1999xlinktype', _ImportedBinding_bindings_v1411_write__xlink.typeType, fixed=True, unicode_default='simple')
    __type._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 29, 1)
    __type._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 112, 2)
    
    type = property(__type.value, __type.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}href uses Python identifier href
    __href = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'href'), 'href', '__httpwww_isotc211_org2005gmd_DS_ProductionSeries_PropertyType_httpwww_w3_org1999xlinkhref', _ImportedBinding_bindings_v1411_write__xlink.hrefType)
    __href._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 42, 1)
    __href._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 113, 2)
    
    href = property(__href.value, __href.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}role uses Python identifier role
    __role = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'role'), 'role', '__httpwww_isotc211_org2005gmd_DS_ProductionSeries_PropertyType_httpwww_w3_org1999xlinkrole', _ImportedBinding_bindings_v1411_write__xlink.roleType)
    __role._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 48, 1)
    __role._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 114, 2)
    
    role = property(__role.value, __role.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}arcrole uses Python identifier arcrole
    __arcrole = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'arcrole'), 'arcrole', '__httpwww_isotc211_org2005gmd_DS_ProductionSeries_PropertyType_httpwww_w3_org1999xlinkarcrole', _ImportedBinding_bindings_v1411_write__xlink.arcroleType)
    __arcrole._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 56, 1)
    __arcrole._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 115, 2)
    
    arcrole = property(__arcrole.value, __arcrole.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}title uses Python identifier title
    __title = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'title'), 'title', '__httpwww_isotc211_org2005gmd_DS_ProductionSeries_PropertyType_httpwww_w3_org1999xlinktitle', _ImportedBinding_bindings_v1411_write__xlink.titleAttrType)
    __title._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 64, 1)
    __title._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 116, 2)
    
    title = property(__title.value, __title.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}show uses Python identifier show
    __show = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'show'), 'show', '__httpwww_isotc211_org2005gmd_DS_ProductionSeries_PropertyType_httpwww_w3_org1999xlinkshow', _ImportedBinding_bindings_v1411_write__xlink.showType)
    __show._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 70, 1)
    __show._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 117, 2)
    
    show = property(__show.value, __show.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}actuate uses Python identifier actuate
    __actuate = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'actuate'), 'actuate', '__httpwww_isotc211_org2005gmd_DS_ProductionSeries_PropertyType_httpwww_w3_org1999xlinkactuate', _ImportedBinding_bindings_v1411_write__xlink.actuateType)
    __actuate._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 82, 1)
    __actuate._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 118, 2)
    
    actuate = property(__actuate.value, __actuate.set, None, None)

    _ElementMap.update({
        __DS_ProductionSeries.name() : __DS_ProductionSeries
    })
    _AttributeMap.update({
        __uuidref.name() : __uuidref,
        __nilReason.name() : __nilReason,
        __type.name() : __type,
        __href.name() : __href,
        __role.name() : __role,
        __arcrole.name() : __arcrole,
        __title.name() : __title,
        __show.name() : __show,
        __actuate.name() : __actuate
    })
_module_typeBindings.DS_ProductionSeries_PropertyType = DS_ProductionSeries_PropertyType
_Namespace_gmd.addCategoryObject('typeBinding', 'DS_ProductionSeries_PropertyType', DS_ProductionSeries_PropertyType)


# Complex type {http://www.isotc211.org/2005/gmd}DS_StereoMate_PropertyType with content type ELEMENT_ONLY
class DS_StereoMate_PropertyType (pyxb.binding.basis.complexTypeDefinition):
    """Complex type {http://www.isotc211.org/2005/gmd}DS_StereoMate_PropertyType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'DS_StereoMate_PropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataApplication.xsd', 168, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.isotc211.org/2005/gmd}DS_StereoMate uses Python identifier DS_StereoMate
    __DS_StereoMate = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'DS_StereoMate'), 'DS_StereoMate', '__httpwww_isotc211_org2005gmd_DS_StereoMate_PropertyType_httpwww_isotc211_org2005gmdDS_StereoMate', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataApplication.xsd', 166, 1), )

    
    DS_StereoMate = property(__DS_StereoMate.value, __DS_StereoMate.set, None, None)

    
    # Attribute uuidref uses Python identifier uuidref
    __uuidref = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'uuidref'), 'uuidref', '__httpwww_isotc211_org2005gmd_DS_StereoMate_PropertyType_uuidref', pyxb.binding.datatypes.string)
    __uuidref._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 30, 2)
    __uuidref._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 30, 2)
    
    uuidref = property(__uuidref.value, __uuidref.set, None, None)

    
    # Attribute {http://www.isotc211.org/2005/gco}nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gco, 'nilReason'), 'nilReason', '__httpwww_isotc211_org2005gmd_DS_StereoMate_PropertyType_httpwww_isotc211_org2005gconilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 33, 1)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataApplication.xsd', 173, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}type uses Python identifier type
    __type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'type'), 'type', '__httpwww_isotc211_org2005gmd_DS_StereoMate_PropertyType_httpwww_w3_org1999xlinktype', _ImportedBinding_bindings_v1411_write__xlink.typeType, fixed=True, unicode_default='simple')
    __type._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 29, 1)
    __type._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 112, 2)
    
    type = property(__type.value, __type.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}href uses Python identifier href
    __href = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'href'), 'href', '__httpwww_isotc211_org2005gmd_DS_StereoMate_PropertyType_httpwww_w3_org1999xlinkhref', _ImportedBinding_bindings_v1411_write__xlink.hrefType)
    __href._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 42, 1)
    __href._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 113, 2)
    
    href = property(__href.value, __href.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}role uses Python identifier role
    __role = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'role'), 'role', '__httpwww_isotc211_org2005gmd_DS_StereoMate_PropertyType_httpwww_w3_org1999xlinkrole', _ImportedBinding_bindings_v1411_write__xlink.roleType)
    __role._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 48, 1)
    __role._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 114, 2)
    
    role = property(__role.value, __role.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}arcrole uses Python identifier arcrole
    __arcrole = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'arcrole'), 'arcrole', '__httpwww_isotc211_org2005gmd_DS_StereoMate_PropertyType_httpwww_w3_org1999xlinkarcrole', _ImportedBinding_bindings_v1411_write__xlink.arcroleType)
    __arcrole._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 56, 1)
    __arcrole._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 115, 2)
    
    arcrole = property(__arcrole.value, __arcrole.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}title uses Python identifier title
    __title = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'title'), 'title', '__httpwww_isotc211_org2005gmd_DS_StereoMate_PropertyType_httpwww_w3_org1999xlinktitle', _ImportedBinding_bindings_v1411_write__xlink.titleAttrType)
    __title._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 64, 1)
    __title._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 116, 2)
    
    title = property(__title.value, __title.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}show uses Python identifier show
    __show = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'show'), 'show', '__httpwww_isotc211_org2005gmd_DS_StereoMate_PropertyType_httpwww_w3_org1999xlinkshow', _ImportedBinding_bindings_v1411_write__xlink.showType)
    __show._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 70, 1)
    __show._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 117, 2)
    
    show = property(__show.value, __show.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}actuate uses Python identifier actuate
    __actuate = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'actuate'), 'actuate', '__httpwww_isotc211_org2005gmd_DS_StereoMate_PropertyType_httpwww_w3_org1999xlinkactuate', _ImportedBinding_bindings_v1411_write__xlink.actuateType)
    __actuate._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 82, 1)
    __actuate._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 118, 2)
    
    actuate = property(__actuate.value, __actuate.set, None, None)

    _ElementMap.update({
        __DS_StereoMate.name() : __DS_StereoMate
    })
    _AttributeMap.update({
        __uuidref.name() : __uuidref,
        __nilReason.name() : __nilReason,
        __type.name() : __type,
        __href.name() : __href,
        __role.name() : __role,
        __arcrole.name() : __arcrole,
        __title.name() : __title,
        __show.name() : __show,
        __actuate.name() : __actuate
    })
_module_typeBindings.DS_StereoMate_PropertyType = DS_StereoMate_PropertyType
_Namespace_gmd.addCategoryObject('typeBinding', 'DS_StereoMate_PropertyType', DS_StereoMate_PropertyType)


# Complex type {http://www.isotc211.org/2005/gmd}MD_Metadata_PropertyType with content type ELEMENT_ONLY
class MD_Metadata_PropertyType (pyxb.binding.basis.complexTypeDefinition):
    """Complex type {http://www.isotc211.org/2005/gmd}MD_Metadata_PropertyType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_Metadata_PropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataEntity.xsd', 63, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.isotc211.org/2005/gmd}MD_Metadata uses Python identifier MD_Metadata
    __MD_Metadata = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_Metadata'), 'MD_Metadata', '__httpwww_isotc211_org2005gmd_MD_Metadata_PropertyType_httpwww_isotc211_org2005gmdMD_Metadata', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataEntity.xsd', 61, 1), )

    
    MD_Metadata = property(__MD_Metadata.value, __MD_Metadata.set, None, None)

    
    # Attribute uuidref uses Python identifier uuidref
    __uuidref = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'uuidref'), 'uuidref', '__httpwww_isotc211_org2005gmd_MD_Metadata_PropertyType_uuidref', pyxb.binding.datatypes.string)
    __uuidref._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 30, 2)
    __uuidref._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 30, 2)
    
    uuidref = property(__uuidref.value, __uuidref.set, None, None)

    
    # Attribute {http://www.isotc211.org/2005/gco}nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gco, 'nilReason'), 'nilReason', '__httpwww_isotc211_org2005gmd_MD_Metadata_PropertyType_httpwww_isotc211_org2005gconilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 33, 1)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataEntity.xsd', 68, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}type uses Python identifier type
    __type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'type'), 'type', '__httpwww_isotc211_org2005gmd_MD_Metadata_PropertyType_httpwww_w3_org1999xlinktype', _ImportedBinding_bindings_v1411_write__xlink.typeType, fixed=True, unicode_default='simple')
    __type._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 29, 1)
    __type._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 112, 2)
    
    type = property(__type.value, __type.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}href uses Python identifier href
    __href = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'href'), 'href', '__httpwww_isotc211_org2005gmd_MD_Metadata_PropertyType_httpwww_w3_org1999xlinkhref', _ImportedBinding_bindings_v1411_write__xlink.hrefType)
    __href._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 42, 1)
    __href._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 113, 2)
    
    href = property(__href.value, __href.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}role uses Python identifier role
    __role = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'role'), 'role', '__httpwww_isotc211_org2005gmd_MD_Metadata_PropertyType_httpwww_w3_org1999xlinkrole', _ImportedBinding_bindings_v1411_write__xlink.roleType)
    __role._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 48, 1)
    __role._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 114, 2)
    
    role = property(__role.value, __role.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}arcrole uses Python identifier arcrole
    __arcrole = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'arcrole'), 'arcrole', '__httpwww_isotc211_org2005gmd_MD_Metadata_PropertyType_httpwww_w3_org1999xlinkarcrole', _ImportedBinding_bindings_v1411_write__xlink.arcroleType)
    __arcrole._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 56, 1)
    __arcrole._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 115, 2)
    
    arcrole = property(__arcrole.value, __arcrole.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}title uses Python identifier title
    __title = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'title'), 'title', '__httpwww_isotc211_org2005gmd_MD_Metadata_PropertyType_httpwww_w3_org1999xlinktitle', _ImportedBinding_bindings_v1411_write__xlink.titleAttrType)
    __title._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 64, 1)
    __title._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 116, 2)
    
    title = property(__title.value, __title.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}show uses Python identifier show
    __show = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'show'), 'show', '__httpwww_isotc211_org2005gmd_MD_Metadata_PropertyType_httpwww_w3_org1999xlinkshow', _ImportedBinding_bindings_v1411_write__xlink.showType)
    __show._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 70, 1)
    __show._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 117, 2)
    
    show = property(__show.value, __show.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}actuate uses Python identifier actuate
    __actuate = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'actuate'), 'actuate', '__httpwww_isotc211_org2005gmd_MD_Metadata_PropertyType_httpwww_w3_org1999xlinkactuate', _ImportedBinding_bindings_v1411_write__xlink.actuateType)
    __actuate._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 82, 1)
    __actuate._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 118, 2)
    
    actuate = property(__actuate.value, __actuate.set, None, None)

    _ElementMap.update({
        __MD_Metadata.name() : __MD_Metadata
    })
    _AttributeMap.update({
        __uuidref.name() : __uuidref,
        __nilReason.name() : __nilReason,
        __type.name() : __type,
        __href.name() : __href,
        __role.name() : __role,
        __arcrole.name() : __arcrole,
        __title.name() : __title,
        __show.name() : __show,
        __actuate.name() : __actuate
    })
_module_typeBindings.MD_Metadata_PropertyType = MD_Metadata_PropertyType
_Namespace_gmd.addCategoryObject('typeBinding', 'MD_Metadata_PropertyType', MD_Metadata_PropertyType)


# Complex type {http://www.isotc211.org/2005/gmd}MD_ExtendedElementInformation_PropertyType with content type ELEMENT_ONLY
class MD_ExtendedElementInformation_PropertyType (pyxb.binding.basis.complexTypeDefinition):
    """Complex type {http://www.isotc211.org/2005/gmd}MD_ExtendedElementInformation_PropertyType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_ExtendedElementInformation_PropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataExtension.xsd', 41, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.isotc211.org/2005/gmd}MD_ExtendedElementInformation uses Python identifier MD_ExtendedElementInformation
    __MD_ExtendedElementInformation = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_ExtendedElementInformation'), 'MD_ExtendedElementInformation', '__httpwww_isotc211_org2005gmd_MD_ExtendedElementInformation_PropertyType_httpwww_isotc211_org2005gmdMD_ExtendedElementInformation', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataExtension.xsd', 39, 1), )

    
    MD_ExtendedElementInformation = property(__MD_ExtendedElementInformation.value, __MD_ExtendedElementInformation.set, None, None)

    
    # Attribute uuidref uses Python identifier uuidref
    __uuidref = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'uuidref'), 'uuidref', '__httpwww_isotc211_org2005gmd_MD_ExtendedElementInformation_PropertyType_uuidref', pyxb.binding.datatypes.string)
    __uuidref._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 30, 2)
    __uuidref._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 30, 2)
    
    uuidref = property(__uuidref.value, __uuidref.set, None, None)

    
    # Attribute {http://www.isotc211.org/2005/gco}nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gco, 'nilReason'), 'nilReason', '__httpwww_isotc211_org2005gmd_MD_ExtendedElementInformation_PropertyType_httpwww_isotc211_org2005gconilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 33, 1)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataExtension.xsd', 46, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}type uses Python identifier type
    __type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'type'), 'type', '__httpwww_isotc211_org2005gmd_MD_ExtendedElementInformation_PropertyType_httpwww_w3_org1999xlinktype', _ImportedBinding_bindings_v1411_write__xlink.typeType, fixed=True, unicode_default='simple')
    __type._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 29, 1)
    __type._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 112, 2)
    
    type = property(__type.value, __type.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}href uses Python identifier href
    __href = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'href'), 'href', '__httpwww_isotc211_org2005gmd_MD_ExtendedElementInformation_PropertyType_httpwww_w3_org1999xlinkhref', _ImportedBinding_bindings_v1411_write__xlink.hrefType)
    __href._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 42, 1)
    __href._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 113, 2)
    
    href = property(__href.value, __href.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}role uses Python identifier role
    __role = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'role'), 'role', '__httpwww_isotc211_org2005gmd_MD_ExtendedElementInformation_PropertyType_httpwww_w3_org1999xlinkrole', _ImportedBinding_bindings_v1411_write__xlink.roleType)
    __role._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 48, 1)
    __role._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 114, 2)
    
    role = property(__role.value, __role.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}arcrole uses Python identifier arcrole
    __arcrole = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'arcrole'), 'arcrole', '__httpwww_isotc211_org2005gmd_MD_ExtendedElementInformation_PropertyType_httpwww_w3_org1999xlinkarcrole', _ImportedBinding_bindings_v1411_write__xlink.arcroleType)
    __arcrole._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 56, 1)
    __arcrole._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 115, 2)
    
    arcrole = property(__arcrole.value, __arcrole.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}title uses Python identifier title
    __title = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'title'), 'title', '__httpwww_isotc211_org2005gmd_MD_ExtendedElementInformation_PropertyType_httpwww_w3_org1999xlinktitle', _ImportedBinding_bindings_v1411_write__xlink.titleAttrType)
    __title._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 64, 1)
    __title._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 116, 2)
    
    title = property(__title.value, __title.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}show uses Python identifier show
    __show = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'show'), 'show', '__httpwww_isotc211_org2005gmd_MD_ExtendedElementInformation_PropertyType_httpwww_w3_org1999xlinkshow', _ImportedBinding_bindings_v1411_write__xlink.showType)
    __show._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 70, 1)
    __show._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 117, 2)
    
    show = property(__show.value, __show.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}actuate uses Python identifier actuate
    __actuate = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'actuate'), 'actuate', '__httpwww_isotc211_org2005gmd_MD_ExtendedElementInformation_PropertyType_httpwww_w3_org1999xlinkactuate', _ImportedBinding_bindings_v1411_write__xlink.actuateType)
    __actuate._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 82, 1)
    __actuate._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 118, 2)
    
    actuate = property(__actuate.value, __actuate.set, None, None)

    _ElementMap.update({
        __MD_ExtendedElementInformation.name() : __MD_ExtendedElementInformation
    })
    _AttributeMap.update({
        __uuidref.name() : __uuidref,
        __nilReason.name() : __nilReason,
        __type.name() : __type,
        __href.name() : __href,
        __role.name() : __role,
        __arcrole.name() : __arcrole,
        __title.name() : __title,
        __show.name() : __show,
        __actuate.name() : __actuate
    })
_module_typeBindings.MD_ExtendedElementInformation_PropertyType = MD_ExtendedElementInformation_PropertyType
_Namespace_gmd.addCategoryObject('typeBinding', 'MD_ExtendedElementInformation_PropertyType', MD_ExtendedElementInformation_PropertyType)


# Complex type {http://www.isotc211.org/2005/gmd}MD_MetadataExtensionInformation_PropertyType with content type ELEMENT_ONLY
class MD_MetadataExtensionInformation_PropertyType (pyxb.binding.basis.complexTypeDefinition):
    """Complex type {http://www.isotc211.org/2005/gmd}MD_MetadataExtensionInformation_PropertyType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_MetadataExtensionInformation_PropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataExtension.xsd', 65, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.isotc211.org/2005/gmd}MD_MetadataExtensionInformation uses Python identifier MD_MetadataExtensionInformation
    __MD_MetadataExtensionInformation = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_MetadataExtensionInformation'), 'MD_MetadataExtensionInformation', '__httpwww_isotc211_org2005gmd_MD_MetadataExtensionInformation_PropertyType_httpwww_isotc211_org2005gmdMD_MetadataExtensionInformation', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataExtension.xsd', 63, 1), )

    
    MD_MetadataExtensionInformation = property(__MD_MetadataExtensionInformation.value, __MD_MetadataExtensionInformation.set, None, None)

    
    # Attribute uuidref uses Python identifier uuidref
    __uuidref = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'uuidref'), 'uuidref', '__httpwww_isotc211_org2005gmd_MD_MetadataExtensionInformation_PropertyType_uuidref', pyxb.binding.datatypes.string)
    __uuidref._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 30, 2)
    __uuidref._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 30, 2)
    
    uuidref = property(__uuidref.value, __uuidref.set, None, None)

    
    # Attribute {http://www.isotc211.org/2005/gco}nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gco, 'nilReason'), 'nilReason', '__httpwww_isotc211_org2005gmd_MD_MetadataExtensionInformation_PropertyType_httpwww_isotc211_org2005gconilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 33, 1)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataExtension.xsd', 70, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}type uses Python identifier type
    __type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'type'), 'type', '__httpwww_isotc211_org2005gmd_MD_MetadataExtensionInformation_PropertyType_httpwww_w3_org1999xlinktype', _ImportedBinding_bindings_v1411_write__xlink.typeType, fixed=True, unicode_default='simple')
    __type._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 29, 1)
    __type._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 112, 2)
    
    type = property(__type.value, __type.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}href uses Python identifier href
    __href = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'href'), 'href', '__httpwww_isotc211_org2005gmd_MD_MetadataExtensionInformation_PropertyType_httpwww_w3_org1999xlinkhref', _ImportedBinding_bindings_v1411_write__xlink.hrefType)
    __href._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 42, 1)
    __href._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 113, 2)
    
    href = property(__href.value, __href.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}role uses Python identifier role
    __role = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'role'), 'role', '__httpwww_isotc211_org2005gmd_MD_MetadataExtensionInformation_PropertyType_httpwww_w3_org1999xlinkrole', _ImportedBinding_bindings_v1411_write__xlink.roleType)
    __role._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 48, 1)
    __role._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 114, 2)
    
    role = property(__role.value, __role.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}arcrole uses Python identifier arcrole
    __arcrole = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'arcrole'), 'arcrole', '__httpwww_isotc211_org2005gmd_MD_MetadataExtensionInformation_PropertyType_httpwww_w3_org1999xlinkarcrole', _ImportedBinding_bindings_v1411_write__xlink.arcroleType)
    __arcrole._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 56, 1)
    __arcrole._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 115, 2)
    
    arcrole = property(__arcrole.value, __arcrole.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}title uses Python identifier title
    __title = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'title'), 'title', '__httpwww_isotc211_org2005gmd_MD_MetadataExtensionInformation_PropertyType_httpwww_w3_org1999xlinktitle', _ImportedBinding_bindings_v1411_write__xlink.titleAttrType)
    __title._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 64, 1)
    __title._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 116, 2)
    
    title = property(__title.value, __title.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}show uses Python identifier show
    __show = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'show'), 'show', '__httpwww_isotc211_org2005gmd_MD_MetadataExtensionInformation_PropertyType_httpwww_w3_org1999xlinkshow', _ImportedBinding_bindings_v1411_write__xlink.showType)
    __show._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 70, 1)
    __show._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 117, 2)
    
    show = property(__show.value, __show.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}actuate uses Python identifier actuate
    __actuate = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'actuate'), 'actuate', '__httpwww_isotc211_org2005gmd_MD_MetadataExtensionInformation_PropertyType_httpwww_w3_org1999xlinkactuate', _ImportedBinding_bindings_v1411_write__xlink.actuateType)
    __actuate._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 82, 1)
    __actuate._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 118, 2)
    
    actuate = property(__actuate.value, __actuate.set, None, None)

    _ElementMap.update({
        __MD_MetadataExtensionInformation.name() : __MD_MetadataExtensionInformation
    })
    _AttributeMap.update({
        __uuidref.name() : __uuidref,
        __nilReason.name() : __nilReason,
        __type.name() : __type,
        __href.name() : __href,
        __role.name() : __role,
        __arcrole.name() : __arcrole,
        __title.name() : __title,
        __show.name() : __show,
        __actuate.name() : __actuate
    })
_module_typeBindings.MD_MetadataExtensionInformation_PropertyType = MD_MetadataExtensionInformation_PropertyType
_Namespace_gmd.addCategoryObject('typeBinding', 'MD_MetadataExtensionInformation_PropertyType', MD_MetadataExtensionInformation_PropertyType)


# Complex type {http://www.isotc211.org/2005/gmd}MD_ObligationCode_PropertyType with content type ELEMENT_ONLY
class MD_ObligationCode_PropertyType (pyxb.binding.basis.complexTypeDefinition):
    """Complex type {http://www.isotc211.org/2005/gmd}MD_ObligationCode_PropertyType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_ObligationCode_PropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataExtension.xsd', 83, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.isotc211.org/2005/gmd}MD_ObligationCode uses Python identifier MD_ObligationCode
    __MD_ObligationCode = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_ObligationCode'), 'MD_ObligationCode', '__httpwww_isotc211_org2005gmd_MD_ObligationCode_PropertyType_httpwww_isotc211_org2005gmdMD_ObligationCode', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataExtension.xsd', 81, 1), )

    
    MD_ObligationCode = property(__MD_ObligationCode.value, __MD_ObligationCode.set, None, None)

    
    # Attribute {http://www.isotc211.org/2005/gco}nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gco, 'nilReason'), 'nilReason', '__httpwww_isotc211_org2005gmd_MD_ObligationCode_PropertyType_httpwww_isotc211_org2005gconilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 33, 1)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataExtension.xsd', 87, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    _ElementMap.update({
        __MD_ObligationCode.name() : __MD_ObligationCode
    })
    _AttributeMap.update({
        __nilReason.name() : __nilReason
    })
_module_typeBindings.MD_ObligationCode_PropertyType = MD_ObligationCode_PropertyType
_Namespace_gmd.addCategoryObject('typeBinding', 'MD_ObligationCode_PropertyType', MD_ObligationCode_PropertyType)


# Complex type {http://www.isotc211.org/2005/gmd}MD_DatatypeCode_PropertyType with content type ELEMENT_ONLY
class MD_DatatypeCode_PropertyType (pyxb.binding.basis.complexTypeDefinition):
    """Complex type {http://www.isotc211.org/2005/gmd}MD_DatatypeCode_PropertyType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_DatatypeCode_PropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataExtension.xsd', 93, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.isotc211.org/2005/gmd}MD_DatatypeCode uses Python identifier MD_DatatypeCode
    __MD_DatatypeCode = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_DatatypeCode'), 'MD_DatatypeCode', '__httpwww_isotc211_org2005gmd_MD_DatatypeCode_PropertyType_httpwww_isotc211_org2005gmdMD_DatatypeCode', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataExtension.xsd', 91, 1), )

    
    MD_DatatypeCode = property(__MD_DatatypeCode.value, __MD_DatatypeCode.set, None, None)

    
    # Attribute {http://www.isotc211.org/2005/gco}nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gco, 'nilReason'), 'nilReason', '__httpwww_isotc211_org2005gmd_MD_DatatypeCode_PropertyType_httpwww_isotc211_org2005gconilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 33, 1)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataExtension.xsd', 97, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    _ElementMap.update({
        __MD_DatatypeCode.name() : __MD_DatatypeCode
    })
    _AttributeMap.update({
        __nilReason.name() : __nilReason
    })
_module_typeBindings.MD_DatatypeCode_PropertyType = MD_DatatypeCode_PropertyType
_Namespace_gmd.addCategoryObject('typeBinding', 'MD_DatatypeCode_PropertyType', MD_DatatypeCode_PropertyType)


# Complex type {http://www.isotc211.org/2005/gmd}MD_PortrayalCatalogueReference_PropertyType with content type ELEMENT_ONLY
class MD_PortrayalCatalogueReference_PropertyType (pyxb.binding.basis.complexTypeDefinition):
    """Complex type {http://www.isotc211.org/2005/gmd}MD_PortrayalCatalogueReference_PropertyType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_PortrayalCatalogueReference_PropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/portrayalCatalogue.xsd', 29, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.isotc211.org/2005/gmd}MD_PortrayalCatalogueReference uses Python identifier MD_PortrayalCatalogueReference
    __MD_PortrayalCatalogueReference = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_PortrayalCatalogueReference'), 'MD_PortrayalCatalogueReference', '__httpwww_isotc211_org2005gmd_MD_PortrayalCatalogueReference_PropertyType_httpwww_isotc211_org2005gmdMD_PortrayalCatalogueReference', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/portrayalCatalogue.xsd', 27, 1), )

    
    MD_PortrayalCatalogueReference = property(__MD_PortrayalCatalogueReference.value, __MD_PortrayalCatalogueReference.set, None, None)

    
    # Attribute uuidref uses Python identifier uuidref
    __uuidref = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'uuidref'), 'uuidref', '__httpwww_isotc211_org2005gmd_MD_PortrayalCatalogueReference_PropertyType_uuidref', pyxb.binding.datatypes.string)
    __uuidref._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 30, 2)
    __uuidref._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 30, 2)
    
    uuidref = property(__uuidref.value, __uuidref.set, None, None)

    
    # Attribute {http://www.isotc211.org/2005/gco}nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gco, 'nilReason'), 'nilReason', '__httpwww_isotc211_org2005gmd_MD_PortrayalCatalogueReference_PropertyType_httpwww_isotc211_org2005gconilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 33, 1)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/portrayalCatalogue.xsd', 34, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}type uses Python identifier type
    __type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'type'), 'type', '__httpwww_isotc211_org2005gmd_MD_PortrayalCatalogueReference_PropertyType_httpwww_w3_org1999xlinktype', _ImportedBinding_bindings_v1411_write__xlink.typeType, fixed=True, unicode_default='simple')
    __type._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 29, 1)
    __type._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 112, 2)
    
    type = property(__type.value, __type.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}href uses Python identifier href
    __href = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'href'), 'href', '__httpwww_isotc211_org2005gmd_MD_PortrayalCatalogueReference_PropertyType_httpwww_w3_org1999xlinkhref', _ImportedBinding_bindings_v1411_write__xlink.hrefType)
    __href._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 42, 1)
    __href._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 113, 2)
    
    href = property(__href.value, __href.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}role uses Python identifier role
    __role = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'role'), 'role', '__httpwww_isotc211_org2005gmd_MD_PortrayalCatalogueReference_PropertyType_httpwww_w3_org1999xlinkrole', _ImportedBinding_bindings_v1411_write__xlink.roleType)
    __role._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 48, 1)
    __role._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 114, 2)
    
    role = property(__role.value, __role.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}arcrole uses Python identifier arcrole
    __arcrole = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'arcrole'), 'arcrole', '__httpwww_isotc211_org2005gmd_MD_PortrayalCatalogueReference_PropertyType_httpwww_w3_org1999xlinkarcrole', _ImportedBinding_bindings_v1411_write__xlink.arcroleType)
    __arcrole._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 56, 1)
    __arcrole._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 115, 2)
    
    arcrole = property(__arcrole.value, __arcrole.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}title uses Python identifier title
    __title = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'title'), 'title', '__httpwww_isotc211_org2005gmd_MD_PortrayalCatalogueReference_PropertyType_httpwww_w3_org1999xlinktitle', _ImportedBinding_bindings_v1411_write__xlink.titleAttrType)
    __title._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 64, 1)
    __title._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 116, 2)
    
    title = property(__title.value, __title.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}show uses Python identifier show
    __show = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'show'), 'show', '__httpwww_isotc211_org2005gmd_MD_PortrayalCatalogueReference_PropertyType_httpwww_w3_org1999xlinkshow', _ImportedBinding_bindings_v1411_write__xlink.showType)
    __show._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 70, 1)
    __show._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 117, 2)
    
    show = property(__show.value, __show.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}actuate uses Python identifier actuate
    __actuate = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'actuate'), 'actuate', '__httpwww_isotc211_org2005gmd_MD_PortrayalCatalogueReference_PropertyType_httpwww_w3_org1999xlinkactuate', _ImportedBinding_bindings_v1411_write__xlink.actuateType)
    __actuate._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 82, 1)
    __actuate._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 118, 2)
    
    actuate = property(__actuate.value, __actuate.set, None, None)

    _ElementMap.update({
        __MD_PortrayalCatalogueReference.name() : __MD_PortrayalCatalogueReference
    })
    _AttributeMap.update({
        __uuidref.name() : __uuidref,
        __nilReason.name() : __nilReason,
        __type.name() : __type,
        __href.name() : __href,
        __role.name() : __role,
        __arcrole.name() : __arcrole,
        __title.name() : __title,
        __show.name() : __show,
        __actuate.name() : __actuate
    })
_module_typeBindings.MD_PortrayalCatalogueReference_PropertyType = MD_PortrayalCatalogueReference_PropertyType
_Namespace_gmd.addCategoryObject('typeBinding', 'MD_PortrayalCatalogueReference_PropertyType', MD_PortrayalCatalogueReference_PropertyType)


# Complex type {http://www.isotc211.org/2005/gmd}RS_Identifier_Type with content type ELEMENT_ONLY
class RS_Identifier_Type (MD_Identifier_Type):
    """Complex type {http://www.isotc211.org/2005/gmd}RS_Identifier_Type with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'RS_Identifier_Type')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/referenceSystem.xsd', 15, 1)
    _ElementMap = MD_Identifier_Type._ElementMap.copy()
    _AttributeMap = MD_Identifier_Type._AttributeMap.copy()
    # Base type is MD_Identifier_Type
    
    # Element {http://www.isotc211.org/2005/gmd}codeSpace uses Python identifier codeSpace
    __codeSpace = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'codeSpace'), 'codeSpace', '__httpwww_isotc211_org2005gmd_RS_Identifier_Type_httpwww_isotc211_org2005gmdcodeSpace', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/referenceSystem.xsd', 19, 5), )

    
    codeSpace = property(__codeSpace.value, __codeSpace.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}version uses Python identifier version
    __version = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'version'), 'version', '__httpwww_isotc211_org2005gmd_RS_Identifier_Type_httpwww_isotc211_org2005gmdversion', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/referenceSystem.xsd', 20, 5), )

    
    version = property(__version.value, __version.set, None, None)

    
    # Element authority ({http://www.isotc211.org/2005/gmd}authority) inherited from {http://www.isotc211.org/2005/gmd}MD_Identifier_Type
    
    # Element code ({http://www.isotc211.org/2005/gmd}code) inherited from {http://www.isotc211.org/2005/gmd}MD_Identifier_Type
    
    # Attribute id inherited from {http://www.isotc211.org/2005/gco}AbstractObject_Type
    
    # Attribute uuid inherited from {http://www.isotc211.org/2005/gco}AbstractObject_Type
    _ElementMap.update({
        __codeSpace.name() : __codeSpace,
        __version.name() : __version
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.RS_Identifier_Type = RS_Identifier_Type
_Namespace_gmd.addCategoryObject('typeBinding', 'RS_Identifier_Type', RS_Identifier_Type)


# Complex type {http://www.isotc211.org/2005/gmd}RS_Identifier_PropertyType with content type ELEMENT_ONLY
class RS_Identifier_PropertyType (pyxb.binding.basis.complexTypeDefinition):
    """Complex type {http://www.isotc211.org/2005/gmd}RS_Identifier_PropertyType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'RS_Identifier_PropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/referenceSystem.xsd', 28, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.isotc211.org/2005/gmd}RS_Identifier uses Python identifier RS_Identifier
    __RS_Identifier = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'RS_Identifier'), 'RS_Identifier', '__httpwww_isotc211_org2005gmd_RS_Identifier_PropertyType_httpwww_isotc211_org2005gmdRS_Identifier', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/referenceSystem.xsd', 26, 1), )

    
    RS_Identifier = property(__RS_Identifier.value, __RS_Identifier.set, None, None)

    
    # Attribute uuidref uses Python identifier uuidref
    __uuidref = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'uuidref'), 'uuidref', '__httpwww_isotc211_org2005gmd_RS_Identifier_PropertyType_uuidref', pyxb.binding.datatypes.string)
    __uuidref._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 30, 2)
    __uuidref._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 30, 2)
    
    uuidref = property(__uuidref.value, __uuidref.set, None, None)

    
    # Attribute {http://www.isotc211.org/2005/gco}nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gco, 'nilReason'), 'nilReason', '__httpwww_isotc211_org2005gmd_RS_Identifier_PropertyType_httpwww_isotc211_org2005gconilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 33, 1)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/referenceSystem.xsd', 33, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}type uses Python identifier type
    __type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'type'), 'type', '__httpwww_isotc211_org2005gmd_RS_Identifier_PropertyType_httpwww_w3_org1999xlinktype', _ImportedBinding_bindings_v1411_write__xlink.typeType, fixed=True, unicode_default='simple')
    __type._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 29, 1)
    __type._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 112, 2)
    
    type = property(__type.value, __type.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}href uses Python identifier href
    __href = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'href'), 'href', '__httpwww_isotc211_org2005gmd_RS_Identifier_PropertyType_httpwww_w3_org1999xlinkhref', _ImportedBinding_bindings_v1411_write__xlink.hrefType)
    __href._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 42, 1)
    __href._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 113, 2)
    
    href = property(__href.value, __href.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}role uses Python identifier role
    __role = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'role'), 'role', '__httpwww_isotc211_org2005gmd_RS_Identifier_PropertyType_httpwww_w3_org1999xlinkrole', _ImportedBinding_bindings_v1411_write__xlink.roleType)
    __role._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 48, 1)
    __role._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 114, 2)
    
    role = property(__role.value, __role.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}arcrole uses Python identifier arcrole
    __arcrole = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'arcrole'), 'arcrole', '__httpwww_isotc211_org2005gmd_RS_Identifier_PropertyType_httpwww_w3_org1999xlinkarcrole', _ImportedBinding_bindings_v1411_write__xlink.arcroleType)
    __arcrole._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 56, 1)
    __arcrole._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 115, 2)
    
    arcrole = property(__arcrole.value, __arcrole.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}title uses Python identifier title
    __title = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'title'), 'title', '__httpwww_isotc211_org2005gmd_RS_Identifier_PropertyType_httpwww_w3_org1999xlinktitle', _ImportedBinding_bindings_v1411_write__xlink.titleAttrType)
    __title._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 64, 1)
    __title._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 116, 2)
    
    title = property(__title.value, __title.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}show uses Python identifier show
    __show = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'show'), 'show', '__httpwww_isotc211_org2005gmd_RS_Identifier_PropertyType_httpwww_w3_org1999xlinkshow', _ImportedBinding_bindings_v1411_write__xlink.showType)
    __show._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 70, 1)
    __show._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 117, 2)
    
    show = property(__show.value, __show.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}actuate uses Python identifier actuate
    __actuate = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'actuate'), 'actuate', '__httpwww_isotc211_org2005gmd_RS_Identifier_PropertyType_httpwww_w3_org1999xlinkactuate', _ImportedBinding_bindings_v1411_write__xlink.actuateType)
    __actuate._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 82, 1)
    __actuate._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 118, 2)
    
    actuate = property(__actuate.value, __actuate.set, None, None)

    _ElementMap.update({
        __RS_Identifier.name() : __RS_Identifier
    })
    _AttributeMap.update({
        __uuidref.name() : __uuidref,
        __nilReason.name() : __nilReason,
        __type.name() : __type,
        __href.name() : __href,
        __role.name() : __role,
        __arcrole.name() : __arcrole,
        __title.name() : __title,
        __show.name() : __show,
        __actuate.name() : __actuate
    })
_module_typeBindings.RS_Identifier_PropertyType = RS_Identifier_PropertyType
_Namespace_gmd.addCategoryObject('typeBinding', 'RS_Identifier_PropertyType', RS_Identifier_PropertyType)


# Complex type {http://www.isotc211.org/2005/gmd}MD_ReferenceSystem_PropertyType with content type ELEMENT_ONLY
class MD_ReferenceSystem_PropertyType (pyxb.binding.basis.complexTypeDefinition):
    """Complex type {http://www.isotc211.org/2005/gmd}MD_ReferenceSystem_PropertyType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_ReferenceSystem_PropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/referenceSystem.xsd', 48, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.isotc211.org/2005/gmd}MD_ReferenceSystem uses Python identifier MD_ReferenceSystem
    __MD_ReferenceSystem = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_ReferenceSystem'), 'MD_ReferenceSystem', '__httpwww_isotc211_org2005gmd_MD_ReferenceSystem_PropertyType_httpwww_isotc211_org2005gmdMD_ReferenceSystem', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/referenceSystem.xsd', 46, 1), )

    
    MD_ReferenceSystem = property(__MD_ReferenceSystem.value, __MD_ReferenceSystem.set, None, None)

    
    # Attribute uuidref uses Python identifier uuidref
    __uuidref = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'uuidref'), 'uuidref', '__httpwww_isotc211_org2005gmd_MD_ReferenceSystem_PropertyType_uuidref', pyxb.binding.datatypes.string)
    __uuidref._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 30, 2)
    __uuidref._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 30, 2)
    
    uuidref = property(__uuidref.value, __uuidref.set, None, None)

    
    # Attribute {http://www.isotc211.org/2005/gco}nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gco, 'nilReason'), 'nilReason', '__httpwww_isotc211_org2005gmd_MD_ReferenceSystem_PropertyType_httpwww_isotc211_org2005gconilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 33, 1)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/referenceSystem.xsd', 53, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}type uses Python identifier type
    __type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'type'), 'type', '__httpwww_isotc211_org2005gmd_MD_ReferenceSystem_PropertyType_httpwww_w3_org1999xlinktype', _ImportedBinding_bindings_v1411_write__xlink.typeType, fixed=True, unicode_default='simple')
    __type._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 29, 1)
    __type._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 112, 2)
    
    type = property(__type.value, __type.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}href uses Python identifier href
    __href = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'href'), 'href', '__httpwww_isotc211_org2005gmd_MD_ReferenceSystem_PropertyType_httpwww_w3_org1999xlinkhref', _ImportedBinding_bindings_v1411_write__xlink.hrefType)
    __href._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 42, 1)
    __href._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 113, 2)
    
    href = property(__href.value, __href.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}role uses Python identifier role
    __role = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'role'), 'role', '__httpwww_isotc211_org2005gmd_MD_ReferenceSystem_PropertyType_httpwww_w3_org1999xlinkrole', _ImportedBinding_bindings_v1411_write__xlink.roleType)
    __role._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 48, 1)
    __role._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 114, 2)
    
    role = property(__role.value, __role.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}arcrole uses Python identifier arcrole
    __arcrole = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'arcrole'), 'arcrole', '__httpwww_isotc211_org2005gmd_MD_ReferenceSystem_PropertyType_httpwww_w3_org1999xlinkarcrole', _ImportedBinding_bindings_v1411_write__xlink.arcroleType)
    __arcrole._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 56, 1)
    __arcrole._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 115, 2)
    
    arcrole = property(__arcrole.value, __arcrole.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}title uses Python identifier title
    __title = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'title'), 'title', '__httpwww_isotc211_org2005gmd_MD_ReferenceSystem_PropertyType_httpwww_w3_org1999xlinktitle', _ImportedBinding_bindings_v1411_write__xlink.titleAttrType)
    __title._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 64, 1)
    __title._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 116, 2)
    
    title = property(__title.value, __title.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}show uses Python identifier show
    __show = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'show'), 'show', '__httpwww_isotc211_org2005gmd_MD_ReferenceSystem_PropertyType_httpwww_w3_org1999xlinkshow', _ImportedBinding_bindings_v1411_write__xlink.showType)
    __show._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 70, 1)
    __show._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 117, 2)
    
    show = property(__show.value, __show.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}actuate uses Python identifier actuate
    __actuate = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'actuate'), 'actuate', '__httpwww_isotc211_org2005gmd_MD_ReferenceSystem_PropertyType_httpwww_w3_org1999xlinkactuate', _ImportedBinding_bindings_v1411_write__xlink.actuateType)
    __actuate._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 82, 1)
    __actuate._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 118, 2)
    
    actuate = property(__actuate.value, __actuate.set, None, None)

    _ElementMap.update({
        __MD_ReferenceSystem.name() : __MD_ReferenceSystem
    })
    _AttributeMap.update({
        __uuidref.name() : __uuidref,
        __nilReason.name() : __nilReason,
        __type.name() : __type,
        __href.name() : __href,
        __role.name() : __role,
        __arcrole.name() : __arcrole,
        __title.name() : __title,
        __show.name() : __show,
        __actuate.name() : __actuate
    })
_module_typeBindings.MD_ReferenceSystem_PropertyType = MD_ReferenceSystem_PropertyType
_Namespace_gmd.addCategoryObject('typeBinding', 'MD_ReferenceSystem_PropertyType', MD_ReferenceSystem_PropertyType)


# Complex type {http://www.isotc211.org/2005/gmd}MD_Identifier_PropertyType with content type ELEMENT_ONLY
class MD_Identifier_PropertyType (pyxb.binding.basis.complexTypeDefinition):
    """Complex type {http://www.isotc211.org/2005/gmd}MD_Identifier_PropertyType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_Identifier_PropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/referenceSystem.xsd', 69, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.isotc211.org/2005/gmd}MD_Identifier uses Python identifier MD_Identifier
    __MD_Identifier = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_Identifier'), 'MD_Identifier', '__httpwww_isotc211_org2005gmd_MD_Identifier_PropertyType_httpwww_isotc211_org2005gmdMD_Identifier', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/referenceSystem.xsd', 67, 1), )

    
    MD_Identifier = property(__MD_Identifier.value, __MD_Identifier.set, None, None)

    
    # Attribute uuidref uses Python identifier uuidref
    __uuidref = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'uuidref'), 'uuidref', '__httpwww_isotc211_org2005gmd_MD_Identifier_PropertyType_uuidref', pyxb.binding.datatypes.string)
    __uuidref._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 30, 2)
    __uuidref._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 30, 2)
    
    uuidref = property(__uuidref.value, __uuidref.set, None, None)

    
    # Attribute {http://www.isotc211.org/2005/gco}nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gco, 'nilReason'), 'nilReason', '__httpwww_isotc211_org2005gmd_MD_Identifier_PropertyType_httpwww_isotc211_org2005gconilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 33, 1)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/referenceSystem.xsd', 74, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}type uses Python identifier type
    __type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'type'), 'type', '__httpwww_isotc211_org2005gmd_MD_Identifier_PropertyType_httpwww_w3_org1999xlinktype', _ImportedBinding_bindings_v1411_write__xlink.typeType, fixed=True, unicode_default='simple')
    __type._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 29, 1)
    __type._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 112, 2)
    
    type = property(__type.value, __type.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}href uses Python identifier href
    __href = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'href'), 'href', '__httpwww_isotc211_org2005gmd_MD_Identifier_PropertyType_httpwww_w3_org1999xlinkhref', _ImportedBinding_bindings_v1411_write__xlink.hrefType)
    __href._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 42, 1)
    __href._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 113, 2)
    
    href = property(__href.value, __href.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}role uses Python identifier role
    __role = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'role'), 'role', '__httpwww_isotc211_org2005gmd_MD_Identifier_PropertyType_httpwww_w3_org1999xlinkrole', _ImportedBinding_bindings_v1411_write__xlink.roleType)
    __role._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 48, 1)
    __role._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 114, 2)
    
    role = property(__role.value, __role.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}arcrole uses Python identifier arcrole
    __arcrole = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'arcrole'), 'arcrole', '__httpwww_isotc211_org2005gmd_MD_Identifier_PropertyType_httpwww_w3_org1999xlinkarcrole', _ImportedBinding_bindings_v1411_write__xlink.arcroleType)
    __arcrole._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 56, 1)
    __arcrole._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 115, 2)
    
    arcrole = property(__arcrole.value, __arcrole.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}title uses Python identifier title
    __title = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'title'), 'title', '__httpwww_isotc211_org2005gmd_MD_Identifier_PropertyType_httpwww_w3_org1999xlinktitle', _ImportedBinding_bindings_v1411_write__xlink.titleAttrType)
    __title._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 64, 1)
    __title._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 116, 2)
    
    title = property(__title.value, __title.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}show uses Python identifier show
    __show = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'show'), 'show', '__httpwww_isotc211_org2005gmd_MD_Identifier_PropertyType_httpwww_w3_org1999xlinkshow', _ImportedBinding_bindings_v1411_write__xlink.showType)
    __show._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 70, 1)
    __show._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 117, 2)
    
    show = property(__show.value, __show.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}actuate uses Python identifier actuate
    __actuate = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'actuate'), 'actuate', '__httpwww_isotc211_org2005gmd_MD_Identifier_PropertyType_httpwww_w3_org1999xlinkactuate', _ImportedBinding_bindings_v1411_write__xlink.actuateType)
    __actuate._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 82, 1)
    __actuate._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 118, 2)
    
    actuate = property(__actuate.value, __actuate.set, None, None)

    _ElementMap.update({
        __MD_Identifier.name() : __MD_Identifier
    })
    _AttributeMap.update({
        __uuidref.name() : __uuidref,
        __nilReason.name() : __nilReason,
        __type.name() : __type,
        __href.name() : __href,
        __role.name() : __role,
        __arcrole.name() : __arcrole,
        __title.name() : __title,
        __show.name() : __show,
        __actuate.name() : __actuate
    })
_module_typeBindings.MD_Identifier_PropertyType = MD_Identifier_PropertyType
_Namespace_gmd.addCategoryObject('typeBinding', 'MD_Identifier_PropertyType', MD_Identifier_PropertyType)


# Complex type {http://www.isotc211.org/2005/gmd}RS_ReferenceSystem_PropertyType with content type ELEMENT_ONLY
class RS_ReferenceSystem_PropertyType (pyxb.binding.basis.complexTypeDefinition):
    """Complex type {http://www.isotc211.org/2005/gmd}RS_ReferenceSystem_PropertyType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'RS_ReferenceSystem_PropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/referenceSystem.xsd', 93, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.isotc211.org/2005/gmd}AbstractRS_ReferenceSystem uses Python identifier AbstractRS_ReferenceSystem
    __AbstractRS_ReferenceSystem = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'AbstractRS_ReferenceSystem'), 'AbstractRS_ReferenceSystem', '__httpwww_isotc211_org2005gmd_RS_ReferenceSystem_PropertyType_httpwww_isotc211_org2005gmdAbstractRS_ReferenceSystem', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/referenceSystem.xsd', 91, 1), )

    
    AbstractRS_ReferenceSystem = property(__AbstractRS_ReferenceSystem.value, __AbstractRS_ReferenceSystem.set, None, None)

    
    # Attribute uuidref uses Python identifier uuidref
    __uuidref = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'uuidref'), 'uuidref', '__httpwww_isotc211_org2005gmd_RS_ReferenceSystem_PropertyType_uuidref', pyxb.binding.datatypes.string)
    __uuidref._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 30, 2)
    __uuidref._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 30, 2)
    
    uuidref = property(__uuidref.value, __uuidref.set, None, None)

    
    # Attribute {http://www.isotc211.org/2005/gco}nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gco, 'nilReason'), 'nilReason', '__httpwww_isotc211_org2005gmd_RS_ReferenceSystem_PropertyType_httpwww_isotc211_org2005gconilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 33, 1)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/referenceSystem.xsd', 98, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}type uses Python identifier type
    __type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'type'), 'type', '__httpwww_isotc211_org2005gmd_RS_ReferenceSystem_PropertyType_httpwww_w3_org1999xlinktype', _ImportedBinding_bindings_v1411_write__xlink.typeType, fixed=True, unicode_default='simple')
    __type._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 29, 1)
    __type._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 112, 2)
    
    type = property(__type.value, __type.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}href uses Python identifier href
    __href = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'href'), 'href', '__httpwww_isotc211_org2005gmd_RS_ReferenceSystem_PropertyType_httpwww_w3_org1999xlinkhref', _ImportedBinding_bindings_v1411_write__xlink.hrefType)
    __href._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 42, 1)
    __href._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 113, 2)
    
    href = property(__href.value, __href.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}role uses Python identifier role
    __role = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'role'), 'role', '__httpwww_isotc211_org2005gmd_RS_ReferenceSystem_PropertyType_httpwww_w3_org1999xlinkrole', _ImportedBinding_bindings_v1411_write__xlink.roleType)
    __role._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 48, 1)
    __role._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 114, 2)
    
    role = property(__role.value, __role.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}arcrole uses Python identifier arcrole
    __arcrole = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'arcrole'), 'arcrole', '__httpwww_isotc211_org2005gmd_RS_ReferenceSystem_PropertyType_httpwww_w3_org1999xlinkarcrole', _ImportedBinding_bindings_v1411_write__xlink.arcroleType)
    __arcrole._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 56, 1)
    __arcrole._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 115, 2)
    
    arcrole = property(__arcrole.value, __arcrole.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}title uses Python identifier title
    __title = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'title'), 'title', '__httpwww_isotc211_org2005gmd_RS_ReferenceSystem_PropertyType_httpwww_w3_org1999xlinktitle', _ImportedBinding_bindings_v1411_write__xlink.titleAttrType)
    __title._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 64, 1)
    __title._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 116, 2)
    
    title = property(__title.value, __title.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}show uses Python identifier show
    __show = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'show'), 'show', '__httpwww_isotc211_org2005gmd_RS_ReferenceSystem_PropertyType_httpwww_w3_org1999xlinkshow', _ImportedBinding_bindings_v1411_write__xlink.showType)
    __show._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 70, 1)
    __show._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 117, 2)
    
    show = property(__show.value, __show.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}actuate uses Python identifier actuate
    __actuate = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'actuate'), 'actuate', '__httpwww_isotc211_org2005gmd_RS_ReferenceSystem_PropertyType_httpwww_w3_org1999xlinkactuate', _ImportedBinding_bindings_v1411_write__xlink.actuateType)
    __actuate._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 82, 1)
    __actuate._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 118, 2)
    
    actuate = property(__actuate.value, __actuate.set, None, None)

    _ElementMap.update({
        __AbstractRS_ReferenceSystem.name() : __AbstractRS_ReferenceSystem
    })
    _AttributeMap.update({
        __uuidref.name() : __uuidref,
        __nilReason.name() : __nilReason,
        __type.name() : __type,
        __href.name() : __href,
        __role.name() : __role,
        __arcrole.name() : __arcrole,
        __title.name() : __title,
        __show.name() : __show,
        __actuate.name() : __actuate
    })
_module_typeBindings.RS_ReferenceSystem_PropertyType = RS_ReferenceSystem_PropertyType
_Namespace_gmd.addCategoryObject('typeBinding', 'RS_ReferenceSystem_PropertyType', RS_ReferenceSystem_PropertyType)


# Complex type {http://www.isotc211.org/2005/gmd}MD_GridSpatialRepresentation_Type with content type ELEMENT_ONLY
class MD_GridSpatialRepresentation_Type (AbstractMD_SpatialRepresentation_Type):
    """Types and numbers of raster spatial objects in the dataset"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_GridSpatialRepresentation_Type')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/spatialRepresentation.xsd', 15, 1)
    _ElementMap = AbstractMD_SpatialRepresentation_Type._ElementMap.copy()
    _AttributeMap = AbstractMD_SpatialRepresentation_Type._AttributeMap.copy()
    # Base type is AbstractMD_SpatialRepresentation_Type
    
    # Element {http://www.isotc211.org/2005/gmd}numberOfDimensions uses Python identifier numberOfDimensions
    __numberOfDimensions = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'numberOfDimensions'), 'numberOfDimensions', '__httpwww_isotc211_org2005gmd_MD_GridSpatialRepresentation_Type_httpwww_isotc211_org2005gmdnumberOfDimensions', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/spatialRepresentation.xsd', 22, 5), )

    
    numberOfDimensions = property(__numberOfDimensions.value, __numberOfDimensions.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}axisDimensionProperties uses Python identifier axisDimensionProperties
    __axisDimensionProperties = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'axisDimensionProperties'), 'axisDimensionProperties', '__httpwww_isotc211_org2005gmd_MD_GridSpatialRepresentation_Type_httpwww_isotc211_org2005gmdaxisDimensionProperties', True, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/spatialRepresentation.xsd', 23, 5), )

    
    axisDimensionProperties = property(__axisDimensionProperties.value, __axisDimensionProperties.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}cellGeometry uses Python identifier cellGeometry
    __cellGeometry = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'cellGeometry'), 'cellGeometry', '__httpwww_isotc211_org2005gmd_MD_GridSpatialRepresentation_Type_httpwww_isotc211_org2005gmdcellGeometry', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/spatialRepresentation.xsd', 24, 5), )

    
    cellGeometry = property(__cellGeometry.value, __cellGeometry.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}transformationParameterAvailability uses Python identifier transformationParameterAvailability
    __transformationParameterAvailability = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'transformationParameterAvailability'), 'transformationParameterAvailability', '__httpwww_isotc211_org2005gmd_MD_GridSpatialRepresentation_Type_httpwww_isotc211_org2005gmdtransformationParameterAvailability', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/spatialRepresentation.xsd', 25, 5), )

    
    transformationParameterAvailability = property(__transformationParameterAvailability.value, __transformationParameterAvailability.set, None, None)

    
    # Attribute id inherited from {http://www.isotc211.org/2005/gco}AbstractObject_Type
    
    # Attribute uuid inherited from {http://www.isotc211.org/2005/gco}AbstractObject_Type
    _ElementMap.update({
        __numberOfDimensions.name() : __numberOfDimensions,
        __axisDimensionProperties.name() : __axisDimensionProperties,
        __cellGeometry.name() : __cellGeometry,
        __transformationParameterAvailability.name() : __transformationParameterAvailability
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.MD_GridSpatialRepresentation_Type = MD_GridSpatialRepresentation_Type
_Namespace_gmd.addCategoryObject('typeBinding', 'MD_GridSpatialRepresentation_Type', MD_GridSpatialRepresentation_Type)


# Complex type {http://www.isotc211.org/2005/gmd}MD_GridSpatialRepresentation_PropertyType with content type ELEMENT_ONLY
class MD_GridSpatialRepresentation_PropertyType (pyxb.binding.basis.complexTypeDefinition):
    """Complex type {http://www.isotc211.org/2005/gmd}MD_GridSpatialRepresentation_PropertyType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_GridSpatialRepresentation_PropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/spatialRepresentation.xsd', 33, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.isotc211.org/2005/gmd}MD_GridSpatialRepresentation uses Python identifier MD_GridSpatialRepresentation
    __MD_GridSpatialRepresentation = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_GridSpatialRepresentation'), 'MD_GridSpatialRepresentation', '__httpwww_isotc211_org2005gmd_MD_GridSpatialRepresentation_PropertyType_httpwww_isotc211_org2005gmdMD_GridSpatialRepresentation', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/spatialRepresentation.xsd', 31, 1), )

    
    MD_GridSpatialRepresentation = property(__MD_GridSpatialRepresentation.value, __MD_GridSpatialRepresentation.set, None, None)

    
    # Attribute uuidref uses Python identifier uuidref
    __uuidref = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'uuidref'), 'uuidref', '__httpwww_isotc211_org2005gmd_MD_GridSpatialRepresentation_PropertyType_uuidref', pyxb.binding.datatypes.string)
    __uuidref._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 30, 2)
    __uuidref._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 30, 2)
    
    uuidref = property(__uuidref.value, __uuidref.set, None, None)

    
    # Attribute {http://www.isotc211.org/2005/gco}nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gco, 'nilReason'), 'nilReason', '__httpwww_isotc211_org2005gmd_MD_GridSpatialRepresentation_PropertyType_httpwww_isotc211_org2005gconilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 33, 1)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/spatialRepresentation.xsd', 38, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}type uses Python identifier type
    __type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'type'), 'type', '__httpwww_isotc211_org2005gmd_MD_GridSpatialRepresentation_PropertyType_httpwww_w3_org1999xlinktype', _ImportedBinding_bindings_v1411_write__xlink.typeType, fixed=True, unicode_default='simple')
    __type._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 29, 1)
    __type._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 112, 2)
    
    type = property(__type.value, __type.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}href uses Python identifier href
    __href = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'href'), 'href', '__httpwww_isotc211_org2005gmd_MD_GridSpatialRepresentation_PropertyType_httpwww_w3_org1999xlinkhref', _ImportedBinding_bindings_v1411_write__xlink.hrefType)
    __href._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 42, 1)
    __href._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 113, 2)
    
    href = property(__href.value, __href.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}role uses Python identifier role
    __role = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'role'), 'role', '__httpwww_isotc211_org2005gmd_MD_GridSpatialRepresentation_PropertyType_httpwww_w3_org1999xlinkrole', _ImportedBinding_bindings_v1411_write__xlink.roleType)
    __role._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 48, 1)
    __role._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 114, 2)
    
    role = property(__role.value, __role.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}arcrole uses Python identifier arcrole
    __arcrole = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'arcrole'), 'arcrole', '__httpwww_isotc211_org2005gmd_MD_GridSpatialRepresentation_PropertyType_httpwww_w3_org1999xlinkarcrole', _ImportedBinding_bindings_v1411_write__xlink.arcroleType)
    __arcrole._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 56, 1)
    __arcrole._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 115, 2)
    
    arcrole = property(__arcrole.value, __arcrole.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}title uses Python identifier title
    __title = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'title'), 'title', '__httpwww_isotc211_org2005gmd_MD_GridSpatialRepresentation_PropertyType_httpwww_w3_org1999xlinktitle', _ImportedBinding_bindings_v1411_write__xlink.titleAttrType)
    __title._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 64, 1)
    __title._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 116, 2)
    
    title = property(__title.value, __title.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}show uses Python identifier show
    __show = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'show'), 'show', '__httpwww_isotc211_org2005gmd_MD_GridSpatialRepresentation_PropertyType_httpwww_w3_org1999xlinkshow', _ImportedBinding_bindings_v1411_write__xlink.showType)
    __show._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 70, 1)
    __show._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 117, 2)
    
    show = property(__show.value, __show.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}actuate uses Python identifier actuate
    __actuate = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'actuate'), 'actuate', '__httpwww_isotc211_org2005gmd_MD_GridSpatialRepresentation_PropertyType_httpwww_w3_org1999xlinkactuate', _ImportedBinding_bindings_v1411_write__xlink.actuateType)
    __actuate._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 82, 1)
    __actuate._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 118, 2)
    
    actuate = property(__actuate.value, __actuate.set, None, None)

    _ElementMap.update({
        __MD_GridSpatialRepresentation.name() : __MD_GridSpatialRepresentation
    })
    _AttributeMap.update({
        __uuidref.name() : __uuidref,
        __nilReason.name() : __nilReason,
        __type.name() : __type,
        __href.name() : __href,
        __role.name() : __role,
        __arcrole.name() : __arcrole,
        __title.name() : __title,
        __show.name() : __show,
        __actuate.name() : __actuate
    })
_module_typeBindings.MD_GridSpatialRepresentation_PropertyType = MD_GridSpatialRepresentation_PropertyType
_Namespace_gmd.addCategoryObject('typeBinding', 'MD_GridSpatialRepresentation_PropertyType', MD_GridSpatialRepresentation_PropertyType)


# Complex type {http://www.isotc211.org/2005/gmd}MD_VectorSpatialRepresentation_Type with content type ELEMENT_ONLY
class MD_VectorSpatialRepresentation_Type (AbstractMD_SpatialRepresentation_Type):
    """Information about the vector spatial objects in the dataset"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_VectorSpatialRepresentation_Type')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/spatialRepresentation.xsd', 41, 1)
    _ElementMap = AbstractMD_SpatialRepresentation_Type._ElementMap.copy()
    _AttributeMap = AbstractMD_SpatialRepresentation_Type._AttributeMap.copy()
    # Base type is AbstractMD_SpatialRepresentation_Type
    
    # Element {http://www.isotc211.org/2005/gmd}topologyLevel uses Python identifier topologyLevel
    __topologyLevel = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'topologyLevel'), 'topologyLevel', '__httpwww_isotc211_org2005gmd_MD_VectorSpatialRepresentation_Type_httpwww_isotc211_org2005gmdtopologyLevel', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/spatialRepresentation.xsd', 48, 5), )

    
    topologyLevel = property(__topologyLevel.value, __topologyLevel.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}geometricObjects uses Python identifier geometricObjects
    __geometricObjects = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'geometricObjects'), 'geometricObjects', '__httpwww_isotc211_org2005gmd_MD_VectorSpatialRepresentation_Type_httpwww_isotc211_org2005gmdgeometricObjects', True, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/spatialRepresentation.xsd', 49, 5), )

    
    geometricObjects = property(__geometricObjects.value, __geometricObjects.set, None, None)

    
    # Attribute id inherited from {http://www.isotc211.org/2005/gco}AbstractObject_Type
    
    # Attribute uuid inherited from {http://www.isotc211.org/2005/gco}AbstractObject_Type
    _ElementMap.update({
        __topologyLevel.name() : __topologyLevel,
        __geometricObjects.name() : __geometricObjects
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.MD_VectorSpatialRepresentation_Type = MD_VectorSpatialRepresentation_Type
_Namespace_gmd.addCategoryObject('typeBinding', 'MD_VectorSpatialRepresentation_Type', MD_VectorSpatialRepresentation_Type)


# Complex type {http://www.isotc211.org/2005/gmd}MD_VectorSpatialRepresentation_PropertyType with content type ELEMENT_ONLY
class MD_VectorSpatialRepresentation_PropertyType (pyxb.binding.basis.complexTypeDefinition):
    """Complex type {http://www.isotc211.org/2005/gmd}MD_VectorSpatialRepresentation_PropertyType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_VectorSpatialRepresentation_PropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/spatialRepresentation.xsd', 57, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.isotc211.org/2005/gmd}MD_VectorSpatialRepresentation uses Python identifier MD_VectorSpatialRepresentation
    __MD_VectorSpatialRepresentation = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_VectorSpatialRepresentation'), 'MD_VectorSpatialRepresentation', '__httpwww_isotc211_org2005gmd_MD_VectorSpatialRepresentation_PropertyType_httpwww_isotc211_org2005gmdMD_VectorSpatialRepresentation', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/spatialRepresentation.xsd', 55, 1), )

    
    MD_VectorSpatialRepresentation = property(__MD_VectorSpatialRepresentation.value, __MD_VectorSpatialRepresentation.set, None, None)

    
    # Attribute uuidref uses Python identifier uuidref
    __uuidref = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'uuidref'), 'uuidref', '__httpwww_isotc211_org2005gmd_MD_VectorSpatialRepresentation_PropertyType_uuidref', pyxb.binding.datatypes.string)
    __uuidref._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 30, 2)
    __uuidref._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 30, 2)
    
    uuidref = property(__uuidref.value, __uuidref.set, None, None)

    
    # Attribute {http://www.isotc211.org/2005/gco}nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gco, 'nilReason'), 'nilReason', '__httpwww_isotc211_org2005gmd_MD_VectorSpatialRepresentation_PropertyType_httpwww_isotc211_org2005gconilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 33, 1)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/spatialRepresentation.xsd', 62, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}type uses Python identifier type
    __type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'type'), 'type', '__httpwww_isotc211_org2005gmd_MD_VectorSpatialRepresentation_PropertyType_httpwww_w3_org1999xlinktype', _ImportedBinding_bindings_v1411_write__xlink.typeType, fixed=True, unicode_default='simple')
    __type._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 29, 1)
    __type._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 112, 2)
    
    type = property(__type.value, __type.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}href uses Python identifier href
    __href = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'href'), 'href', '__httpwww_isotc211_org2005gmd_MD_VectorSpatialRepresentation_PropertyType_httpwww_w3_org1999xlinkhref', _ImportedBinding_bindings_v1411_write__xlink.hrefType)
    __href._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 42, 1)
    __href._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 113, 2)
    
    href = property(__href.value, __href.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}role uses Python identifier role
    __role = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'role'), 'role', '__httpwww_isotc211_org2005gmd_MD_VectorSpatialRepresentation_PropertyType_httpwww_w3_org1999xlinkrole', _ImportedBinding_bindings_v1411_write__xlink.roleType)
    __role._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 48, 1)
    __role._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 114, 2)
    
    role = property(__role.value, __role.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}arcrole uses Python identifier arcrole
    __arcrole = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'arcrole'), 'arcrole', '__httpwww_isotc211_org2005gmd_MD_VectorSpatialRepresentation_PropertyType_httpwww_w3_org1999xlinkarcrole', _ImportedBinding_bindings_v1411_write__xlink.arcroleType)
    __arcrole._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 56, 1)
    __arcrole._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 115, 2)
    
    arcrole = property(__arcrole.value, __arcrole.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}title uses Python identifier title
    __title = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'title'), 'title', '__httpwww_isotc211_org2005gmd_MD_VectorSpatialRepresentation_PropertyType_httpwww_w3_org1999xlinktitle', _ImportedBinding_bindings_v1411_write__xlink.titleAttrType)
    __title._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 64, 1)
    __title._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 116, 2)
    
    title = property(__title.value, __title.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}show uses Python identifier show
    __show = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'show'), 'show', '__httpwww_isotc211_org2005gmd_MD_VectorSpatialRepresentation_PropertyType_httpwww_w3_org1999xlinkshow', _ImportedBinding_bindings_v1411_write__xlink.showType)
    __show._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 70, 1)
    __show._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 117, 2)
    
    show = property(__show.value, __show.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}actuate uses Python identifier actuate
    __actuate = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'actuate'), 'actuate', '__httpwww_isotc211_org2005gmd_MD_VectorSpatialRepresentation_PropertyType_httpwww_w3_org1999xlinkactuate', _ImportedBinding_bindings_v1411_write__xlink.actuateType)
    __actuate._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 82, 1)
    __actuate._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 118, 2)
    
    actuate = property(__actuate.value, __actuate.set, None, None)

    _ElementMap.update({
        __MD_VectorSpatialRepresentation.name() : __MD_VectorSpatialRepresentation
    })
    _AttributeMap.update({
        __uuidref.name() : __uuidref,
        __nilReason.name() : __nilReason,
        __type.name() : __type,
        __href.name() : __href,
        __role.name() : __role,
        __arcrole.name() : __arcrole,
        __title.name() : __title,
        __show.name() : __show,
        __actuate.name() : __actuate
    })
_module_typeBindings.MD_VectorSpatialRepresentation_PropertyType = MD_VectorSpatialRepresentation_PropertyType
_Namespace_gmd.addCategoryObject('typeBinding', 'MD_VectorSpatialRepresentation_PropertyType', MD_VectorSpatialRepresentation_PropertyType)


# Complex type {http://www.isotc211.org/2005/gmd}MD_SpatialRepresentation_PropertyType with content type ELEMENT_ONLY
class MD_SpatialRepresentation_PropertyType (pyxb.binding.basis.complexTypeDefinition):
    """Complex type {http://www.isotc211.org/2005/gmd}MD_SpatialRepresentation_PropertyType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_SpatialRepresentation_PropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/spatialRepresentation.xsd', 78, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.isotc211.org/2005/gmd}AbstractMD_SpatialRepresentation uses Python identifier AbstractMD_SpatialRepresentation
    __AbstractMD_SpatialRepresentation = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'AbstractMD_SpatialRepresentation'), 'AbstractMD_SpatialRepresentation', '__httpwww_isotc211_org2005gmd_MD_SpatialRepresentation_PropertyType_httpwww_isotc211_org2005gmdAbstractMD_SpatialRepresentation', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/spatialRepresentation.xsd', 76, 1), )

    
    AbstractMD_SpatialRepresentation = property(__AbstractMD_SpatialRepresentation.value, __AbstractMD_SpatialRepresentation.set, None, None)

    
    # Attribute uuidref uses Python identifier uuidref
    __uuidref = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'uuidref'), 'uuidref', '__httpwww_isotc211_org2005gmd_MD_SpatialRepresentation_PropertyType_uuidref', pyxb.binding.datatypes.string)
    __uuidref._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 30, 2)
    __uuidref._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 30, 2)
    
    uuidref = property(__uuidref.value, __uuidref.set, None, None)

    
    # Attribute {http://www.isotc211.org/2005/gco}nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gco, 'nilReason'), 'nilReason', '__httpwww_isotc211_org2005gmd_MD_SpatialRepresentation_PropertyType_httpwww_isotc211_org2005gconilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 33, 1)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/spatialRepresentation.xsd', 83, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}type uses Python identifier type
    __type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'type'), 'type', '__httpwww_isotc211_org2005gmd_MD_SpatialRepresentation_PropertyType_httpwww_w3_org1999xlinktype', _ImportedBinding_bindings_v1411_write__xlink.typeType, fixed=True, unicode_default='simple')
    __type._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 29, 1)
    __type._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 112, 2)
    
    type = property(__type.value, __type.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}href uses Python identifier href
    __href = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'href'), 'href', '__httpwww_isotc211_org2005gmd_MD_SpatialRepresentation_PropertyType_httpwww_w3_org1999xlinkhref', _ImportedBinding_bindings_v1411_write__xlink.hrefType)
    __href._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 42, 1)
    __href._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 113, 2)
    
    href = property(__href.value, __href.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}role uses Python identifier role
    __role = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'role'), 'role', '__httpwww_isotc211_org2005gmd_MD_SpatialRepresentation_PropertyType_httpwww_w3_org1999xlinkrole', _ImportedBinding_bindings_v1411_write__xlink.roleType)
    __role._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 48, 1)
    __role._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 114, 2)
    
    role = property(__role.value, __role.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}arcrole uses Python identifier arcrole
    __arcrole = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'arcrole'), 'arcrole', '__httpwww_isotc211_org2005gmd_MD_SpatialRepresentation_PropertyType_httpwww_w3_org1999xlinkarcrole', _ImportedBinding_bindings_v1411_write__xlink.arcroleType)
    __arcrole._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 56, 1)
    __arcrole._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 115, 2)
    
    arcrole = property(__arcrole.value, __arcrole.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}title uses Python identifier title
    __title = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'title'), 'title', '__httpwww_isotc211_org2005gmd_MD_SpatialRepresentation_PropertyType_httpwww_w3_org1999xlinktitle', _ImportedBinding_bindings_v1411_write__xlink.titleAttrType)
    __title._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 64, 1)
    __title._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 116, 2)
    
    title = property(__title.value, __title.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}show uses Python identifier show
    __show = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'show'), 'show', '__httpwww_isotc211_org2005gmd_MD_SpatialRepresentation_PropertyType_httpwww_w3_org1999xlinkshow', _ImportedBinding_bindings_v1411_write__xlink.showType)
    __show._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 70, 1)
    __show._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 117, 2)
    
    show = property(__show.value, __show.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}actuate uses Python identifier actuate
    __actuate = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'actuate'), 'actuate', '__httpwww_isotc211_org2005gmd_MD_SpatialRepresentation_PropertyType_httpwww_w3_org1999xlinkactuate', _ImportedBinding_bindings_v1411_write__xlink.actuateType)
    __actuate._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 82, 1)
    __actuate._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 118, 2)
    
    actuate = property(__actuate.value, __actuate.set, None, None)

    _ElementMap.update({
        __AbstractMD_SpatialRepresentation.name() : __AbstractMD_SpatialRepresentation
    })
    _AttributeMap.update({
        __uuidref.name() : __uuidref,
        __nilReason.name() : __nilReason,
        __type.name() : __type,
        __href.name() : __href,
        __role.name() : __role,
        __arcrole.name() : __arcrole,
        __title.name() : __title,
        __show.name() : __show,
        __actuate.name() : __actuate
    })
_module_typeBindings.MD_SpatialRepresentation_PropertyType = MD_SpatialRepresentation_PropertyType
_Namespace_gmd.addCategoryObject('typeBinding', 'MD_SpatialRepresentation_PropertyType', MD_SpatialRepresentation_PropertyType)


# Complex type {http://www.isotc211.org/2005/gmd}MD_Georeferenceable_PropertyType with content type ELEMENT_ONLY
class MD_Georeferenceable_PropertyType (pyxb.binding.basis.complexTypeDefinition):
    """Complex type {http://www.isotc211.org/2005/gmd}MD_Georeferenceable_PropertyType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_Georeferenceable_PropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/spatialRepresentation.xsd', 102, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.isotc211.org/2005/gmd}MD_Georeferenceable uses Python identifier MD_Georeferenceable
    __MD_Georeferenceable = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_Georeferenceable'), 'MD_Georeferenceable', '__httpwww_isotc211_org2005gmd_MD_Georeferenceable_PropertyType_httpwww_isotc211_org2005gmdMD_Georeferenceable', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/spatialRepresentation.xsd', 100, 1), )

    
    MD_Georeferenceable = property(__MD_Georeferenceable.value, __MD_Georeferenceable.set, None, None)

    
    # Attribute uuidref uses Python identifier uuidref
    __uuidref = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'uuidref'), 'uuidref', '__httpwww_isotc211_org2005gmd_MD_Georeferenceable_PropertyType_uuidref', pyxb.binding.datatypes.string)
    __uuidref._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 30, 2)
    __uuidref._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 30, 2)
    
    uuidref = property(__uuidref.value, __uuidref.set, None, None)

    
    # Attribute {http://www.isotc211.org/2005/gco}nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gco, 'nilReason'), 'nilReason', '__httpwww_isotc211_org2005gmd_MD_Georeferenceable_PropertyType_httpwww_isotc211_org2005gconilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 33, 1)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/spatialRepresentation.xsd', 107, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}type uses Python identifier type
    __type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'type'), 'type', '__httpwww_isotc211_org2005gmd_MD_Georeferenceable_PropertyType_httpwww_w3_org1999xlinktype', _ImportedBinding_bindings_v1411_write__xlink.typeType, fixed=True, unicode_default='simple')
    __type._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 29, 1)
    __type._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 112, 2)
    
    type = property(__type.value, __type.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}href uses Python identifier href
    __href = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'href'), 'href', '__httpwww_isotc211_org2005gmd_MD_Georeferenceable_PropertyType_httpwww_w3_org1999xlinkhref', _ImportedBinding_bindings_v1411_write__xlink.hrefType)
    __href._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 42, 1)
    __href._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 113, 2)
    
    href = property(__href.value, __href.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}role uses Python identifier role
    __role = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'role'), 'role', '__httpwww_isotc211_org2005gmd_MD_Georeferenceable_PropertyType_httpwww_w3_org1999xlinkrole', _ImportedBinding_bindings_v1411_write__xlink.roleType)
    __role._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 48, 1)
    __role._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 114, 2)
    
    role = property(__role.value, __role.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}arcrole uses Python identifier arcrole
    __arcrole = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'arcrole'), 'arcrole', '__httpwww_isotc211_org2005gmd_MD_Georeferenceable_PropertyType_httpwww_w3_org1999xlinkarcrole', _ImportedBinding_bindings_v1411_write__xlink.arcroleType)
    __arcrole._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 56, 1)
    __arcrole._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 115, 2)
    
    arcrole = property(__arcrole.value, __arcrole.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}title uses Python identifier title
    __title = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'title'), 'title', '__httpwww_isotc211_org2005gmd_MD_Georeferenceable_PropertyType_httpwww_w3_org1999xlinktitle', _ImportedBinding_bindings_v1411_write__xlink.titleAttrType)
    __title._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 64, 1)
    __title._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 116, 2)
    
    title = property(__title.value, __title.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}show uses Python identifier show
    __show = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'show'), 'show', '__httpwww_isotc211_org2005gmd_MD_Georeferenceable_PropertyType_httpwww_w3_org1999xlinkshow', _ImportedBinding_bindings_v1411_write__xlink.showType)
    __show._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 70, 1)
    __show._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 117, 2)
    
    show = property(__show.value, __show.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}actuate uses Python identifier actuate
    __actuate = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'actuate'), 'actuate', '__httpwww_isotc211_org2005gmd_MD_Georeferenceable_PropertyType_httpwww_w3_org1999xlinkactuate', _ImportedBinding_bindings_v1411_write__xlink.actuateType)
    __actuate._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 82, 1)
    __actuate._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 118, 2)
    
    actuate = property(__actuate.value, __actuate.set, None, None)

    _ElementMap.update({
        __MD_Georeferenceable.name() : __MD_Georeferenceable
    })
    _AttributeMap.update({
        __uuidref.name() : __uuidref,
        __nilReason.name() : __nilReason,
        __type.name() : __type,
        __href.name() : __href,
        __role.name() : __role,
        __arcrole.name() : __arcrole,
        __title.name() : __title,
        __show.name() : __show,
        __actuate.name() : __actuate
    })
_module_typeBindings.MD_Georeferenceable_PropertyType = MD_Georeferenceable_PropertyType
_Namespace_gmd.addCategoryObject('typeBinding', 'MD_Georeferenceable_PropertyType', MD_Georeferenceable_PropertyType)


# Complex type {http://www.isotc211.org/2005/gmd}MD_Dimension_PropertyType with content type ELEMENT_ONLY
class MD_Dimension_PropertyType (pyxb.binding.basis.complexTypeDefinition):
    """Complex type {http://www.isotc211.org/2005/gmd}MD_Dimension_PropertyType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_Dimension_PropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/spatialRepresentation.xsd', 124, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.isotc211.org/2005/gmd}MD_Dimension uses Python identifier MD_Dimension
    __MD_Dimension = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_Dimension'), 'MD_Dimension', '__httpwww_isotc211_org2005gmd_MD_Dimension_PropertyType_httpwww_isotc211_org2005gmdMD_Dimension', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/spatialRepresentation.xsd', 122, 1), )

    
    MD_Dimension = property(__MD_Dimension.value, __MD_Dimension.set, None, None)

    
    # Attribute uuidref uses Python identifier uuidref
    __uuidref = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'uuidref'), 'uuidref', '__httpwww_isotc211_org2005gmd_MD_Dimension_PropertyType_uuidref', pyxb.binding.datatypes.string)
    __uuidref._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 30, 2)
    __uuidref._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 30, 2)
    
    uuidref = property(__uuidref.value, __uuidref.set, None, None)

    
    # Attribute {http://www.isotc211.org/2005/gco}nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gco, 'nilReason'), 'nilReason', '__httpwww_isotc211_org2005gmd_MD_Dimension_PropertyType_httpwww_isotc211_org2005gconilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 33, 1)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/spatialRepresentation.xsd', 129, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}type uses Python identifier type
    __type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'type'), 'type', '__httpwww_isotc211_org2005gmd_MD_Dimension_PropertyType_httpwww_w3_org1999xlinktype', _ImportedBinding_bindings_v1411_write__xlink.typeType, fixed=True, unicode_default='simple')
    __type._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 29, 1)
    __type._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 112, 2)
    
    type = property(__type.value, __type.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}href uses Python identifier href
    __href = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'href'), 'href', '__httpwww_isotc211_org2005gmd_MD_Dimension_PropertyType_httpwww_w3_org1999xlinkhref', _ImportedBinding_bindings_v1411_write__xlink.hrefType)
    __href._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 42, 1)
    __href._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 113, 2)
    
    href = property(__href.value, __href.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}role uses Python identifier role
    __role = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'role'), 'role', '__httpwww_isotc211_org2005gmd_MD_Dimension_PropertyType_httpwww_w3_org1999xlinkrole', _ImportedBinding_bindings_v1411_write__xlink.roleType)
    __role._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 48, 1)
    __role._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 114, 2)
    
    role = property(__role.value, __role.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}arcrole uses Python identifier arcrole
    __arcrole = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'arcrole'), 'arcrole', '__httpwww_isotc211_org2005gmd_MD_Dimension_PropertyType_httpwww_w3_org1999xlinkarcrole', _ImportedBinding_bindings_v1411_write__xlink.arcroleType)
    __arcrole._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 56, 1)
    __arcrole._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 115, 2)
    
    arcrole = property(__arcrole.value, __arcrole.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}title uses Python identifier title
    __title = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'title'), 'title', '__httpwww_isotc211_org2005gmd_MD_Dimension_PropertyType_httpwww_w3_org1999xlinktitle', _ImportedBinding_bindings_v1411_write__xlink.titleAttrType)
    __title._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 64, 1)
    __title._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 116, 2)
    
    title = property(__title.value, __title.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}show uses Python identifier show
    __show = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'show'), 'show', '__httpwww_isotc211_org2005gmd_MD_Dimension_PropertyType_httpwww_w3_org1999xlinkshow', _ImportedBinding_bindings_v1411_write__xlink.showType)
    __show._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 70, 1)
    __show._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 117, 2)
    
    show = property(__show.value, __show.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}actuate uses Python identifier actuate
    __actuate = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'actuate'), 'actuate', '__httpwww_isotc211_org2005gmd_MD_Dimension_PropertyType_httpwww_w3_org1999xlinkactuate', _ImportedBinding_bindings_v1411_write__xlink.actuateType)
    __actuate._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 82, 1)
    __actuate._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 118, 2)
    
    actuate = property(__actuate.value, __actuate.set, None, None)

    _ElementMap.update({
        __MD_Dimension.name() : __MD_Dimension
    })
    _AttributeMap.update({
        __uuidref.name() : __uuidref,
        __nilReason.name() : __nilReason,
        __type.name() : __type,
        __href.name() : __href,
        __role.name() : __role,
        __arcrole.name() : __arcrole,
        __title.name() : __title,
        __show.name() : __show,
        __actuate.name() : __actuate
    })
_module_typeBindings.MD_Dimension_PropertyType = MD_Dimension_PropertyType
_Namespace_gmd.addCategoryObject('typeBinding', 'MD_Dimension_PropertyType', MD_Dimension_PropertyType)


# Complex type {http://www.isotc211.org/2005/gmd}MD_Georectified_PropertyType with content type ELEMENT_ONLY
class MD_Georectified_PropertyType (pyxb.binding.basis.complexTypeDefinition):
    """Complex type {http://www.isotc211.org/2005/gmd}MD_Georectified_PropertyType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_Georectified_PropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/spatialRepresentation.xsd', 150, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.isotc211.org/2005/gmd}MD_Georectified uses Python identifier MD_Georectified
    __MD_Georectified = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_Georectified'), 'MD_Georectified', '__httpwww_isotc211_org2005gmd_MD_Georectified_PropertyType_httpwww_isotc211_org2005gmdMD_Georectified', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/spatialRepresentation.xsd', 148, 1), )

    
    MD_Georectified = property(__MD_Georectified.value, __MD_Georectified.set, None, None)

    
    # Attribute uuidref uses Python identifier uuidref
    __uuidref = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'uuidref'), 'uuidref', '__httpwww_isotc211_org2005gmd_MD_Georectified_PropertyType_uuidref', pyxb.binding.datatypes.string)
    __uuidref._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 30, 2)
    __uuidref._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 30, 2)
    
    uuidref = property(__uuidref.value, __uuidref.set, None, None)

    
    # Attribute {http://www.isotc211.org/2005/gco}nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gco, 'nilReason'), 'nilReason', '__httpwww_isotc211_org2005gmd_MD_Georectified_PropertyType_httpwww_isotc211_org2005gconilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 33, 1)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/spatialRepresentation.xsd', 155, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}type uses Python identifier type
    __type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'type'), 'type', '__httpwww_isotc211_org2005gmd_MD_Georectified_PropertyType_httpwww_w3_org1999xlinktype', _ImportedBinding_bindings_v1411_write__xlink.typeType, fixed=True, unicode_default='simple')
    __type._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 29, 1)
    __type._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 112, 2)
    
    type = property(__type.value, __type.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}href uses Python identifier href
    __href = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'href'), 'href', '__httpwww_isotc211_org2005gmd_MD_Georectified_PropertyType_httpwww_w3_org1999xlinkhref', _ImportedBinding_bindings_v1411_write__xlink.hrefType)
    __href._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 42, 1)
    __href._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 113, 2)
    
    href = property(__href.value, __href.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}role uses Python identifier role
    __role = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'role'), 'role', '__httpwww_isotc211_org2005gmd_MD_Georectified_PropertyType_httpwww_w3_org1999xlinkrole', _ImportedBinding_bindings_v1411_write__xlink.roleType)
    __role._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 48, 1)
    __role._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 114, 2)
    
    role = property(__role.value, __role.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}arcrole uses Python identifier arcrole
    __arcrole = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'arcrole'), 'arcrole', '__httpwww_isotc211_org2005gmd_MD_Georectified_PropertyType_httpwww_w3_org1999xlinkarcrole', _ImportedBinding_bindings_v1411_write__xlink.arcroleType)
    __arcrole._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 56, 1)
    __arcrole._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 115, 2)
    
    arcrole = property(__arcrole.value, __arcrole.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}title uses Python identifier title
    __title = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'title'), 'title', '__httpwww_isotc211_org2005gmd_MD_Georectified_PropertyType_httpwww_w3_org1999xlinktitle', _ImportedBinding_bindings_v1411_write__xlink.titleAttrType)
    __title._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 64, 1)
    __title._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 116, 2)
    
    title = property(__title.value, __title.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}show uses Python identifier show
    __show = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'show'), 'show', '__httpwww_isotc211_org2005gmd_MD_Georectified_PropertyType_httpwww_w3_org1999xlinkshow', _ImportedBinding_bindings_v1411_write__xlink.showType)
    __show._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 70, 1)
    __show._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 117, 2)
    
    show = property(__show.value, __show.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}actuate uses Python identifier actuate
    __actuate = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'actuate'), 'actuate', '__httpwww_isotc211_org2005gmd_MD_Georectified_PropertyType_httpwww_w3_org1999xlinkactuate', _ImportedBinding_bindings_v1411_write__xlink.actuateType)
    __actuate._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 82, 1)
    __actuate._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 118, 2)
    
    actuate = property(__actuate.value, __actuate.set, None, None)

    _ElementMap.update({
        __MD_Georectified.name() : __MD_Georectified
    })
    _AttributeMap.update({
        __uuidref.name() : __uuidref,
        __nilReason.name() : __nilReason,
        __type.name() : __type,
        __href.name() : __href,
        __role.name() : __role,
        __arcrole.name() : __arcrole,
        __title.name() : __title,
        __show.name() : __show,
        __actuate.name() : __actuate
    })
_module_typeBindings.MD_Georectified_PropertyType = MD_Georectified_PropertyType
_Namespace_gmd.addCategoryObject('typeBinding', 'MD_Georectified_PropertyType', MD_Georectified_PropertyType)


# Complex type {http://www.isotc211.org/2005/gmd}MD_GeometricObjects_PropertyType with content type ELEMENT_ONLY
class MD_GeometricObjects_PropertyType (pyxb.binding.basis.complexTypeDefinition):
    """Complex type {http://www.isotc211.org/2005/gmd}MD_GeometricObjects_PropertyType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_GeometricObjects_PropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/spatialRepresentation.xsd', 171, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.isotc211.org/2005/gmd}MD_GeometricObjects uses Python identifier MD_GeometricObjects
    __MD_GeometricObjects = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_GeometricObjects'), 'MD_GeometricObjects', '__httpwww_isotc211_org2005gmd_MD_GeometricObjects_PropertyType_httpwww_isotc211_org2005gmdMD_GeometricObjects', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/spatialRepresentation.xsd', 169, 1), )

    
    MD_GeometricObjects = property(__MD_GeometricObjects.value, __MD_GeometricObjects.set, None, None)

    
    # Attribute uuidref uses Python identifier uuidref
    __uuidref = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'uuidref'), 'uuidref', '__httpwww_isotc211_org2005gmd_MD_GeometricObjects_PropertyType_uuidref', pyxb.binding.datatypes.string)
    __uuidref._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 30, 2)
    __uuidref._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 30, 2)
    
    uuidref = property(__uuidref.value, __uuidref.set, None, None)

    
    # Attribute {http://www.isotc211.org/2005/gco}nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gco, 'nilReason'), 'nilReason', '__httpwww_isotc211_org2005gmd_MD_GeometricObjects_PropertyType_httpwww_isotc211_org2005gconilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 33, 1)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/spatialRepresentation.xsd', 176, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}type uses Python identifier type
    __type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'type'), 'type', '__httpwww_isotc211_org2005gmd_MD_GeometricObjects_PropertyType_httpwww_w3_org1999xlinktype', _ImportedBinding_bindings_v1411_write__xlink.typeType, fixed=True, unicode_default='simple')
    __type._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 29, 1)
    __type._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 112, 2)
    
    type = property(__type.value, __type.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}href uses Python identifier href
    __href = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'href'), 'href', '__httpwww_isotc211_org2005gmd_MD_GeometricObjects_PropertyType_httpwww_w3_org1999xlinkhref', _ImportedBinding_bindings_v1411_write__xlink.hrefType)
    __href._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 42, 1)
    __href._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 113, 2)
    
    href = property(__href.value, __href.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}role uses Python identifier role
    __role = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'role'), 'role', '__httpwww_isotc211_org2005gmd_MD_GeometricObjects_PropertyType_httpwww_w3_org1999xlinkrole', _ImportedBinding_bindings_v1411_write__xlink.roleType)
    __role._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 48, 1)
    __role._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 114, 2)
    
    role = property(__role.value, __role.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}arcrole uses Python identifier arcrole
    __arcrole = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'arcrole'), 'arcrole', '__httpwww_isotc211_org2005gmd_MD_GeometricObjects_PropertyType_httpwww_w3_org1999xlinkarcrole', _ImportedBinding_bindings_v1411_write__xlink.arcroleType)
    __arcrole._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 56, 1)
    __arcrole._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 115, 2)
    
    arcrole = property(__arcrole.value, __arcrole.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}title uses Python identifier title
    __title = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'title'), 'title', '__httpwww_isotc211_org2005gmd_MD_GeometricObjects_PropertyType_httpwww_w3_org1999xlinktitle', _ImportedBinding_bindings_v1411_write__xlink.titleAttrType)
    __title._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 64, 1)
    __title._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 116, 2)
    
    title = property(__title.value, __title.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}show uses Python identifier show
    __show = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'show'), 'show', '__httpwww_isotc211_org2005gmd_MD_GeometricObjects_PropertyType_httpwww_w3_org1999xlinkshow', _ImportedBinding_bindings_v1411_write__xlink.showType)
    __show._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 70, 1)
    __show._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 117, 2)
    
    show = property(__show.value, __show.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}actuate uses Python identifier actuate
    __actuate = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'actuate'), 'actuate', '__httpwww_isotc211_org2005gmd_MD_GeometricObjects_PropertyType_httpwww_w3_org1999xlinkactuate', _ImportedBinding_bindings_v1411_write__xlink.actuateType)
    __actuate._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 82, 1)
    __actuate._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 118, 2)
    
    actuate = property(__actuate.value, __actuate.set, None, None)

    _ElementMap.update({
        __MD_GeometricObjects.name() : __MD_GeometricObjects
    })
    _AttributeMap.update({
        __uuidref.name() : __uuidref,
        __nilReason.name() : __nilReason,
        __type.name() : __type,
        __href.name() : __href,
        __role.name() : __role,
        __arcrole.name() : __arcrole,
        __title.name() : __title,
        __show.name() : __show,
        __actuate.name() : __actuate
    })
_module_typeBindings.MD_GeometricObjects_PropertyType = MD_GeometricObjects_PropertyType
_Namespace_gmd.addCategoryObject('typeBinding', 'MD_GeometricObjects_PropertyType', MD_GeometricObjects_PropertyType)


# Complex type {http://www.isotc211.org/2005/gmd}MD_PixelOrientationCode_PropertyType with content type ELEMENT_ONLY
class MD_PixelOrientationCode_PropertyType (pyxb.binding.basis.complexTypeDefinition):
    """Complex type {http://www.isotc211.org/2005/gmd}MD_PixelOrientationCode_PropertyType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_PixelOrientationCode_PropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/spatialRepresentation.xsd', 191, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.isotc211.org/2005/gmd}MD_PixelOrientationCode uses Python identifier MD_PixelOrientationCode
    __MD_PixelOrientationCode = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_PixelOrientationCode'), 'MD_PixelOrientationCode', '__httpwww_isotc211_org2005gmd_MD_PixelOrientationCode_PropertyType_httpwww_isotc211_org2005gmdMD_PixelOrientationCode', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/spatialRepresentation.xsd', 189, 1), )

    
    MD_PixelOrientationCode = property(__MD_PixelOrientationCode.value, __MD_PixelOrientationCode.set, None, None)

    
    # Attribute {http://www.isotc211.org/2005/gco}nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gco, 'nilReason'), 'nilReason', '__httpwww_isotc211_org2005gmd_MD_PixelOrientationCode_PropertyType_httpwww_isotc211_org2005gconilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 33, 1)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/spatialRepresentation.xsd', 195, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    _ElementMap.update({
        __MD_PixelOrientationCode.name() : __MD_PixelOrientationCode
    })
    _AttributeMap.update({
        __nilReason.name() : __nilReason
    })
_module_typeBindings.MD_PixelOrientationCode_PropertyType = MD_PixelOrientationCode_PropertyType
_Namespace_gmd.addCategoryObject('typeBinding', 'MD_PixelOrientationCode_PropertyType', MD_PixelOrientationCode_PropertyType)


# Complex type {http://www.isotc211.org/2005/gmd}MD_TopologyLevelCode_PropertyType with content type ELEMENT_ONLY
class MD_TopologyLevelCode_PropertyType (pyxb.binding.basis.complexTypeDefinition):
    """Complex type {http://www.isotc211.org/2005/gmd}MD_TopologyLevelCode_PropertyType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_TopologyLevelCode_PropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/spatialRepresentation.xsd', 201, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.isotc211.org/2005/gmd}MD_TopologyLevelCode uses Python identifier MD_TopologyLevelCode
    __MD_TopologyLevelCode = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_TopologyLevelCode'), 'MD_TopologyLevelCode', '__httpwww_isotc211_org2005gmd_MD_TopologyLevelCode_PropertyType_httpwww_isotc211_org2005gmdMD_TopologyLevelCode', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/spatialRepresentation.xsd', 199, 1), )

    
    MD_TopologyLevelCode = property(__MD_TopologyLevelCode.value, __MD_TopologyLevelCode.set, None, None)

    
    # Attribute {http://www.isotc211.org/2005/gco}nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gco, 'nilReason'), 'nilReason', '__httpwww_isotc211_org2005gmd_MD_TopologyLevelCode_PropertyType_httpwww_isotc211_org2005gconilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 33, 1)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/spatialRepresentation.xsd', 205, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    _ElementMap.update({
        __MD_TopologyLevelCode.name() : __MD_TopologyLevelCode
    })
    _AttributeMap.update({
        __nilReason.name() : __nilReason
    })
_module_typeBindings.MD_TopologyLevelCode_PropertyType = MD_TopologyLevelCode_PropertyType
_Namespace_gmd.addCategoryObject('typeBinding', 'MD_TopologyLevelCode_PropertyType', MD_TopologyLevelCode_PropertyType)


# Complex type {http://www.isotc211.org/2005/gmd}MD_GeometricObjectTypeCode_PropertyType with content type ELEMENT_ONLY
class MD_GeometricObjectTypeCode_PropertyType (pyxb.binding.basis.complexTypeDefinition):
    """Complex type {http://www.isotc211.org/2005/gmd}MD_GeometricObjectTypeCode_PropertyType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_GeometricObjectTypeCode_PropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/spatialRepresentation.xsd', 211, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.isotc211.org/2005/gmd}MD_GeometricObjectTypeCode uses Python identifier MD_GeometricObjectTypeCode
    __MD_GeometricObjectTypeCode = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_GeometricObjectTypeCode'), 'MD_GeometricObjectTypeCode', '__httpwww_isotc211_org2005gmd_MD_GeometricObjectTypeCode_PropertyType_httpwww_isotc211_org2005gmdMD_GeometricObjectTypeCode', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/spatialRepresentation.xsd', 209, 1), )

    
    MD_GeometricObjectTypeCode = property(__MD_GeometricObjectTypeCode.value, __MD_GeometricObjectTypeCode.set, None, None)

    
    # Attribute {http://www.isotc211.org/2005/gco}nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gco, 'nilReason'), 'nilReason', '__httpwww_isotc211_org2005gmd_MD_GeometricObjectTypeCode_PropertyType_httpwww_isotc211_org2005gconilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 33, 1)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/spatialRepresentation.xsd', 215, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    _ElementMap.update({
        __MD_GeometricObjectTypeCode.name() : __MD_GeometricObjectTypeCode
    })
    _AttributeMap.update({
        __nilReason.name() : __nilReason
    })
_module_typeBindings.MD_GeometricObjectTypeCode_PropertyType = MD_GeometricObjectTypeCode_PropertyType
_Namespace_gmd.addCategoryObject('typeBinding', 'MD_GeometricObjectTypeCode_PropertyType', MD_GeometricObjectTypeCode_PropertyType)


# Complex type {http://www.isotc211.org/2005/gmd}MD_CellGeometryCode_PropertyType with content type ELEMENT_ONLY
class MD_CellGeometryCode_PropertyType (pyxb.binding.basis.complexTypeDefinition):
    """Complex type {http://www.isotc211.org/2005/gmd}MD_CellGeometryCode_PropertyType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_CellGeometryCode_PropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/spatialRepresentation.xsd', 221, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.isotc211.org/2005/gmd}MD_CellGeometryCode uses Python identifier MD_CellGeometryCode
    __MD_CellGeometryCode = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_CellGeometryCode'), 'MD_CellGeometryCode', '__httpwww_isotc211_org2005gmd_MD_CellGeometryCode_PropertyType_httpwww_isotc211_org2005gmdMD_CellGeometryCode', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/spatialRepresentation.xsd', 219, 1), )

    
    MD_CellGeometryCode = property(__MD_CellGeometryCode.value, __MD_CellGeometryCode.set, None, None)

    
    # Attribute {http://www.isotc211.org/2005/gco}nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gco, 'nilReason'), 'nilReason', '__httpwww_isotc211_org2005gmd_MD_CellGeometryCode_PropertyType_httpwww_isotc211_org2005gconilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 33, 1)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/spatialRepresentation.xsd', 225, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    _ElementMap.update({
        __MD_CellGeometryCode.name() : __MD_CellGeometryCode
    })
    _AttributeMap.update({
        __nilReason.name() : __nilReason
    })
_module_typeBindings.MD_CellGeometryCode_PropertyType = MD_CellGeometryCode_PropertyType
_Namespace_gmd.addCategoryObject('typeBinding', 'MD_CellGeometryCode_PropertyType', MD_CellGeometryCode_PropertyType)


# Complex type {http://www.isotc211.org/2005/gmd}MD_DimensionNameTypeCode_PropertyType with content type ELEMENT_ONLY
class MD_DimensionNameTypeCode_PropertyType (pyxb.binding.basis.complexTypeDefinition):
    """Complex type {http://www.isotc211.org/2005/gmd}MD_DimensionNameTypeCode_PropertyType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_DimensionNameTypeCode_PropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/spatialRepresentation.xsd', 231, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.isotc211.org/2005/gmd}MD_DimensionNameTypeCode uses Python identifier MD_DimensionNameTypeCode
    __MD_DimensionNameTypeCode = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_DimensionNameTypeCode'), 'MD_DimensionNameTypeCode', '__httpwww_isotc211_org2005gmd_MD_DimensionNameTypeCode_PropertyType_httpwww_isotc211_org2005gmdMD_DimensionNameTypeCode', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/spatialRepresentation.xsd', 229, 1), )

    
    MD_DimensionNameTypeCode = property(__MD_DimensionNameTypeCode.value, __MD_DimensionNameTypeCode.set, None, None)

    
    # Attribute {http://www.isotc211.org/2005/gco}nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gco, 'nilReason'), 'nilReason', '__httpwww_isotc211_org2005gmd_MD_DimensionNameTypeCode_PropertyType_httpwww_isotc211_org2005gconilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 33, 1)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/spatialRepresentation.xsd', 235, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    _ElementMap.update({
        __MD_DimensionNameTypeCode.name() : __MD_DimensionNameTypeCode
    })
    _AttributeMap.update({
        __nilReason.name() : __nilReason
    })
_module_typeBindings.MD_DimensionNameTypeCode_PropertyType = MD_DimensionNameTypeCode_PropertyType
_Namespace_gmd.addCategoryObject('typeBinding', 'MD_DimensionNameTypeCode_PropertyType', MD_DimensionNameTypeCode_PropertyType)


# Complex type {http://www.isotc211.org/2005/gsr}SC_CRS_PropertyType with content type ELEMENT_ONLY
class SC_CRS_PropertyType (pyxb.binding.basis.complexTypeDefinition):
    """Complex type {http://www.isotc211.org/2005/gsr}SC_CRS_PropertyType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gsr, 'SC_CRS_PropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gsr/spatialReferencing.xsd', 17, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.opengis.net/gml/3.2}AbstractCRS uses Python identifier AbstractCRS
    __AbstractCRS = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractCRS'), 'AbstractCRS', '__httpwww_isotc211_org2005gsr_SC_CRS_PropertyType_httpwww_opengis_netgml3_2AbstractCRS', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/referenceSystems.xsd', 30, 1), )

    
    AbstractCRS = property(__AbstractCRS.value, __AbstractCRS.set, None, 'gml:AbstractCRS specifies a coordinate reference system which is usually single but may be compound. This abstract complex type shall not be used, extended, or restricted, in a GML Application Schema, to define a concrete subtype with a meaning equivalent to a concrete subtype specified in this document.')

    
    # Attribute uuidref uses Python identifier uuidref
    __uuidref = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'uuidref'), 'uuidref', '__httpwww_isotc211_org2005gsr_SC_CRS_PropertyType_uuidref', pyxb.binding.datatypes.string)
    __uuidref._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 30, 2)
    __uuidref._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 30, 2)
    
    uuidref = property(__uuidref.value, __uuidref.set, None, None)

    
    # Attribute {http://www.isotc211.org/2005/gco}nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gco, 'nilReason'), 'nilReason', '__httpwww_isotc211_org2005gsr_SC_CRS_PropertyType_httpwww_isotc211_org2005gconilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 33, 1)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gsr/spatialReferencing.xsd', 22, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}type uses Python identifier type
    __type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'type'), 'type', '__httpwww_isotc211_org2005gsr_SC_CRS_PropertyType_httpwww_w3_org1999xlinktype', _ImportedBinding_bindings_v1411_write__xlink.typeType, fixed=True, unicode_default='simple')
    __type._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 29, 1)
    __type._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 112, 2)
    
    type = property(__type.value, __type.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}href uses Python identifier href
    __href = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'href'), 'href', '__httpwww_isotc211_org2005gsr_SC_CRS_PropertyType_httpwww_w3_org1999xlinkhref', _ImportedBinding_bindings_v1411_write__xlink.hrefType)
    __href._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 42, 1)
    __href._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 113, 2)
    
    href = property(__href.value, __href.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}role uses Python identifier role
    __role = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'role'), 'role', '__httpwww_isotc211_org2005gsr_SC_CRS_PropertyType_httpwww_w3_org1999xlinkrole', _ImportedBinding_bindings_v1411_write__xlink.roleType)
    __role._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 48, 1)
    __role._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 114, 2)
    
    role = property(__role.value, __role.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}arcrole uses Python identifier arcrole
    __arcrole = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'arcrole'), 'arcrole', '__httpwww_isotc211_org2005gsr_SC_CRS_PropertyType_httpwww_w3_org1999xlinkarcrole', _ImportedBinding_bindings_v1411_write__xlink.arcroleType)
    __arcrole._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 56, 1)
    __arcrole._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 115, 2)
    
    arcrole = property(__arcrole.value, __arcrole.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}title uses Python identifier title
    __title = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'title'), 'title', '__httpwww_isotc211_org2005gsr_SC_CRS_PropertyType_httpwww_w3_org1999xlinktitle', _ImportedBinding_bindings_v1411_write__xlink.titleAttrType)
    __title._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 64, 1)
    __title._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 116, 2)
    
    title = property(__title.value, __title.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}show uses Python identifier show
    __show = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'show'), 'show', '__httpwww_isotc211_org2005gsr_SC_CRS_PropertyType_httpwww_w3_org1999xlinkshow', _ImportedBinding_bindings_v1411_write__xlink.showType)
    __show._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 70, 1)
    __show._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 117, 2)
    
    show = property(__show.value, __show.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}actuate uses Python identifier actuate
    __actuate = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'actuate'), 'actuate', '__httpwww_isotc211_org2005gsr_SC_CRS_PropertyType_httpwww_w3_org1999xlinkactuate', _ImportedBinding_bindings_v1411_write__xlink.actuateType)
    __actuate._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 82, 1)
    __actuate._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 118, 2)
    
    actuate = property(__actuate.value, __actuate.set, None, None)

    _ElementMap.update({
        __AbstractCRS.name() : __AbstractCRS
    })
    _AttributeMap.update({
        __uuidref.name() : __uuidref,
        __nilReason.name() : __nilReason,
        __type.name() : __type,
        __href.name() : __href,
        __role.name() : __role,
        __arcrole.name() : __arcrole,
        __title.name() : __title,
        __show.name() : __show,
        __actuate.name() : __actuate
    })
_module_typeBindings.SC_CRS_PropertyType = SC_CRS_PropertyType
_Namespace_gsr.addCategoryObject('typeBinding', 'SC_CRS_PropertyType', SC_CRS_PropertyType)


# Complex type {http://www.isotc211.org/2005/gss}GM_Point_PropertyType with content type ELEMENT_ONLY
class GM_Point_PropertyType (pyxb.binding.basis.complexTypeDefinition):
    """Complex type {http://www.isotc211.org/2005/gss}GM_Point_PropertyType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gss, 'GM_Point_PropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gss/geometry.xsd', 17, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.opengis.net/gml/3.2}Point uses Python identifier Point
    __Point = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'Point'), 'Point', '__httpwww_isotc211_org2005gss_GM_Point_PropertyType_httpwww_opengis_netgml3_2Point', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic0d1d.xsd', 189, 1), )

    
    Point = property(__Point.value, __Point.set, None, 'A Point is defined by a single coordinate tuple. The direct position of a point is specified by the pos element which is of type DirectPositionType.')

    
    # Attribute uuidref uses Python identifier uuidref
    __uuidref = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'uuidref'), 'uuidref', '__httpwww_isotc211_org2005gss_GM_Point_PropertyType_uuidref', pyxb.binding.datatypes.string)
    __uuidref._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 30, 2)
    __uuidref._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 30, 2)
    
    uuidref = property(__uuidref.value, __uuidref.set, None, None)

    
    # Attribute {http://www.isotc211.org/2005/gco}nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gco, 'nilReason'), 'nilReason', '__httpwww_isotc211_org2005gss_GM_Point_PropertyType_httpwww_isotc211_org2005gconilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 33, 1)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gss/geometry.xsd', 22, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}type uses Python identifier type
    __type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'type'), 'type', '__httpwww_isotc211_org2005gss_GM_Point_PropertyType_httpwww_w3_org1999xlinktype', _ImportedBinding_bindings_v1411_write__xlink.typeType, fixed=True, unicode_default='simple')
    __type._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 29, 1)
    __type._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 112, 2)
    
    type = property(__type.value, __type.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}href uses Python identifier href
    __href = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'href'), 'href', '__httpwww_isotc211_org2005gss_GM_Point_PropertyType_httpwww_w3_org1999xlinkhref', _ImportedBinding_bindings_v1411_write__xlink.hrefType)
    __href._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 42, 1)
    __href._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 113, 2)
    
    href = property(__href.value, __href.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}role uses Python identifier role
    __role = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'role'), 'role', '__httpwww_isotc211_org2005gss_GM_Point_PropertyType_httpwww_w3_org1999xlinkrole', _ImportedBinding_bindings_v1411_write__xlink.roleType)
    __role._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 48, 1)
    __role._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 114, 2)
    
    role = property(__role.value, __role.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}arcrole uses Python identifier arcrole
    __arcrole = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'arcrole'), 'arcrole', '__httpwww_isotc211_org2005gss_GM_Point_PropertyType_httpwww_w3_org1999xlinkarcrole', _ImportedBinding_bindings_v1411_write__xlink.arcroleType)
    __arcrole._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 56, 1)
    __arcrole._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 115, 2)
    
    arcrole = property(__arcrole.value, __arcrole.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}title uses Python identifier title
    __title = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'title'), 'title', '__httpwww_isotc211_org2005gss_GM_Point_PropertyType_httpwww_w3_org1999xlinktitle', _ImportedBinding_bindings_v1411_write__xlink.titleAttrType)
    __title._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 64, 1)
    __title._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 116, 2)
    
    title = property(__title.value, __title.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}show uses Python identifier show
    __show = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'show'), 'show', '__httpwww_isotc211_org2005gss_GM_Point_PropertyType_httpwww_w3_org1999xlinkshow', _ImportedBinding_bindings_v1411_write__xlink.showType)
    __show._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 70, 1)
    __show._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 117, 2)
    
    show = property(__show.value, __show.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}actuate uses Python identifier actuate
    __actuate = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'actuate'), 'actuate', '__httpwww_isotc211_org2005gss_GM_Point_PropertyType_httpwww_w3_org1999xlinkactuate', _ImportedBinding_bindings_v1411_write__xlink.actuateType)
    __actuate._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 82, 1)
    __actuate._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 118, 2)
    
    actuate = property(__actuate.value, __actuate.set, None, None)

    _ElementMap.update({
        __Point.name() : __Point
    })
    _AttributeMap.update({
        __uuidref.name() : __uuidref,
        __nilReason.name() : __nilReason,
        __type.name() : __type,
        __href.name() : __href,
        __role.name() : __role,
        __arcrole.name() : __arcrole,
        __title.name() : __title,
        __show.name() : __show,
        __actuate.name() : __actuate
    })
_module_typeBindings.GM_Point_PropertyType = GM_Point_PropertyType
_Namespace_gss.addCategoryObject('typeBinding', 'GM_Point_PropertyType', GM_Point_PropertyType)


# Complex type {http://www.isotc211.org/2005/gss}GM_Object_PropertyType with content type ELEMENT_ONLY
class GM_Object_PropertyType (pyxb.binding.basis.complexTypeDefinition):
    """Complex type {http://www.isotc211.org/2005/gss}GM_Object_PropertyType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gss, 'GM_Object_PropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gss/geometry.xsd', 28, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.opengis.net/gml/3.2}AbstractGeometry uses Python identifier AbstractGeometry
    __AbstractGeometry = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractGeometry'), 'AbstractGeometry', '__httpwww_isotc211_org2005gss_GM_Object_PropertyType_httpwww_opengis_netgml3_2AbstractGeometry', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic0d1d.xsd', 50, 1), )

    
    AbstractGeometry = property(__AbstractGeometry.value, __AbstractGeometry.set, None, 'The AbstractGeometry element is the abstract head of the substitution group for all geometry elements of GML. This includes pre-defined and user-defined geometry elements. Any geometry element shall be a direct or indirect extension/restriction of AbstractGeometryType and shall be directly or indirectly in the substitution group of AbstractGeometry.')

    
    # Attribute uuidref uses Python identifier uuidref
    __uuidref = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'uuidref'), 'uuidref', '__httpwww_isotc211_org2005gss_GM_Object_PropertyType_uuidref', pyxb.binding.datatypes.string)
    __uuidref._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 30, 2)
    __uuidref._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 30, 2)
    
    uuidref = property(__uuidref.value, __uuidref.set, None, None)

    
    # Attribute {http://www.isotc211.org/2005/gco}nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gco, 'nilReason'), 'nilReason', '__httpwww_isotc211_org2005gss_GM_Object_PropertyType_httpwww_isotc211_org2005gconilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 33, 1)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gss/geometry.xsd', 33, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}type uses Python identifier type
    __type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'type'), 'type', '__httpwww_isotc211_org2005gss_GM_Object_PropertyType_httpwww_w3_org1999xlinktype', _ImportedBinding_bindings_v1411_write__xlink.typeType, fixed=True, unicode_default='simple')
    __type._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 29, 1)
    __type._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 112, 2)
    
    type = property(__type.value, __type.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}href uses Python identifier href
    __href = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'href'), 'href', '__httpwww_isotc211_org2005gss_GM_Object_PropertyType_httpwww_w3_org1999xlinkhref', _ImportedBinding_bindings_v1411_write__xlink.hrefType)
    __href._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 42, 1)
    __href._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 113, 2)
    
    href = property(__href.value, __href.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}role uses Python identifier role
    __role = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'role'), 'role', '__httpwww_isotc211_org2005gss_GM_Object_PropertyType_httpwww_w3_org1999xlinkrole', _ImportedBinding_bindings_v1411_write__xlink.roleType)
    __role._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 48, 1)
    __role._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 114, 2)
    
    role = property(__role.value, __role.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}arcrole uses Python identifier arcrole
    __arcrole = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'arcrole'), 'arcrole', '__httpwww_isotc211_org2005gss_GM_Object_PropertyType_httpwww_w3_org1999xlinkarcrole', _ImportedBinding_bindings_v1411_write__xlink.arcroleType)
    __arcrole._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 56, 1)
    __arcrole._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 115, 2)
    
    arcrole = property(__arcrole.value, __arcrole.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}title uses Python identifier title
    __title = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'title'), 'title', '__httpwww_isotc211_org2005gss_GM_Object_PropertyType_httpwww_w3_org1999xlinktitle', _ImportedBinding_bindings_v1411_write__xlink.titleAttrType)
    __title._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 64, 1)
    __title._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 116, 2)
    
    title = property(__title.value, __title.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}show uses Python identifier show
    __show = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'show'), 'show', '__httpwww_isotc211_org2005gss_GM_Object_PropertyType_httpwww_w3_org1999xlinkshow', _ImportedBinding_bindings_v1411_write__xlink.showType)
    __show._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 70, 1)
    __show._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 117, 2)
    
    show = property(__show.value, __show.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}actuate uses Python identifier actuate
    __actuate = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'actuate'), 'actuate', '__httpwww_isotc211_org2005gss_GM_Object_PropertyType_httpwww_w3_org1999xlinkactuate', _ImportedBinding_bindings_v1411_write__xlink.actuateType)
    __actuate._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 82, 1)
    __actuate._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 118, 2)
    
    actuate = property(__actuate.value, __actuate.set, None, None)

    _ElementMap.update({
        __AbstractGeometry.name() : __AbstractGeometry
    })
    _AttributeMap.update({
        __uuidref.name() : __uuidref,
        __nilReason.name() : __nilReason,
        __type.name() : __type,
        __href.name() : __href,
        __role.name() : __role,
        __arcrole.name() : __arcrole,
        __title.name() : __title,
        __show.name() : __show,
        __actuate.name() : __actuate
    })
_module_typeBindings.GM_Object_PropertyType = GM_Object_PropertyType
_Namespace_gss.addCategoryObject('typeBinding', 'GM_Object_PropertyType', GM_Object_PropertyType)


# Complex type {http://www.isotc211.org/2005/gts}TM_Primitive_PropertyType with content type ELEMENT_ONLY
class TM_Primitive_PropertyType (pyxb.binding.basis.complexTypeDefinition):
    """Complex type {http://www.isotc211.org/2005/gts}TM_Primitive_PropertyType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gts, 'TM_Primitive_PropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gts/temporalObjects.xsd', 17, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.opengis.net/gml/3.2}AbstractTimePrimitive uses Python identifier AbstractTimePrimitive
    __AbstractTimePrimitive = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractTimePrimitive'), 'AbstractTimePrimitive', '__httpwww_isotc211_org2005gts_TM_Primitive_PropertyType_httpwww_opengis_netgml3_2AbstractTimePrimitive', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporal.xsd', 28, 1), )

    
    AbstractTimePrimitive = property(__AbstractTimePrimitive.value, __AbstractTimePrimitive.set, None, 'gml:AbstractTimePrimitive acts as the head of a substitution group for geometric and topological temporal primitives.')

    
    # Attribute uuidref uses Python identifier uuidref
    __uuidref = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'uuidref'), 'uuidref', '__httpwww_isotc211_org2005gts_TM_Primitive_PropertyType_uuidref', pyxb.binding.datatypes.string)
    __uuidref._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 30, 2)
    __uuidref._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 30, 2)
    
    uuidref = property(__uuidref.value, __uuidref.set, None, None)

    
    # Attribute {http://www.isotc211.org/2005/gco}nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gco, 'nilReason'), 'nilReason', '__httpwww_isotc211_org2005gts_TM_Primitive_PropertyType_httpwww_isotc211_org2005gconilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 33, 1)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gts/temporalObjects.xsd', 22, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}type uses Python identifier type
    __type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'type'), 'type', '__httpwww_isotc211_org2005gts_TM_Primitive_PropertyType_httpwww_w3_org1999xlinktype', _ImportedBinding_bindings_v1411_write__xlink.typeType, fixed=True, unicode_default='simple')
    __type._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 29, 1)
    __type._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 112, 2)
    
    type = property(__type.value, __type.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}href uses Python identifier href
    __href = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'href'), 'href', '__httpwww_isotc211_org2005gts_TM_Primitive_PropertyType_httpwww_w3_org1999xlinkhref', _ImportedBinding_bindings_v1411_write__xlink.hrefType)
    __href._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 42, 1)
    __href._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 113, 2)
    
    href = property(__href.value, __href.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}role uses Python identifier role
    __role = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'role'), 'role', '__httpwww_isotc211_org2005gts_TM_Primitive_PropertyType_httpwww_w3_org1999xlinkrole', _ImportedBinding_bindings_v1411_write__xlink.roleType)
    __role._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 48, 1)
    __role._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 114, 2)
    
    role = property(__role.value, __role.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}arcrole uses Python identifier arcrole
    __arcrole = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'arcrole'), 'arcrole', '__httpwww_isotc211_org2005gts_TM_Primitive_PropertyType_httpwww_w3_org1999xlinkarcrole', _ImportedBinding_bindings_v1411_write__xlink.arcroleType)
    __arcrole._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 56, 1)
    __arcrole._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 115, 2)
    
    arcrole = property(__arcrole.value, __arcrole.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}title uses Python identifier title
    __title = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'title'), 'title', '__httpwww_isotc211_org2005gts_TM_Primitive_PropertyType_httpwww_w3_org1999xlinktitle', _ImportedBinding_bindings_v1411_write__xlink.titleAttrType)
    __title._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 64, 1)
    __title._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 116, 2)
    
    title = property(__title.value, __title.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}show uses Python identifier show
    __show = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'show'), 'show', '__httpwww_isotc211_org2005gts_TM_Primitive_PropertyType_httpwww_w3_org1999xlinkshow', _ImportedBinding_bindings_v1411_write__xlink.showType)
    __show._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 70, 1)
    __show._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 117, 2)
    
    show = property(__show.value, __show.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}actuate uses Python identifier actuate
    __actuate = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'actuate'), 'actuate', '__httpwww_isotc211_org2005gts_TM_Primitive_PropertyType_httpwww_w3_org1999xlinkactuate', _ImportedBinding_bindings_v1411_write__xlink.actuateType)
    __actuate._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 82, 1)
    __actuate._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 118, 2)
    
    actuate = property(__actuate.value, __actuate.set, None, None)

    _ElementMap.update({
        __AbstractTimePrimitive.name() : __AbstractTimePrimitive
    })
    _AttributeMap.update({
        __uuidref.name() : __uuidref,
        __nilReason.name() : __nilReason,
        __type.name() : __type,
        __href.name() : __href,
        __role.name() : __role,
        __arcrole.name() : __arcrole,
        __title.name() : __title,
        __show.name() : __show,
        __actuate.name() : __actuate
    })
_module_typeBindings.TM_Primitive_PropertyType = TM_Primitive_PropertyType
_Namespace_gts.addCategoryObject('typeBinding', 'TM_Primitive_PropertyType', TM_Primitive_PropertyType)


# Complex type {http://www.isotc211.org/2005/gts}TM_PeriodDuration_PropertyType with content type ELEMENT_ONLY
class TM_PeriodDuration_PropertyType (pyxb.binding.basis.complexTypeDefinition):
    """Complex type {http://www.isotc211.org/2005/gts}TM_PeriodDuration_PropertyType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gts, 'TM_PeriodDuration_PropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gts/temporalObjects.xsd', 28, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.isotc211.org/2005/gts}TM_PeriodDuration uses Python identifier TM_PeriodDuration
    __TM_PeriodDuration = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gts, 'TM_PeriodDuration'), 'TM_PeriodDuration', '__httpwww_isotc211_org2005gts_TM_PeriodDuration_PropertyType_httpwww_isotc211_org2005gtsTM_PeriodDuration', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gts/temporalObjects.xsd', 26, 1), )

    
    TM_PeriodDuration = property(__TM_PeriodDuration.value, __TM_PeriodDuration.set, None, None)

    
    # Attribute {http://www.isotc211.org/2005/gco}nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gco, 'nilReason'), 'nilReason', '__httpwww_isotc211_org2005gts_TM_PeriodDuration_PropertyType_httpwww_isotc211_org2005gconilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 33, 1)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gts/temporalObjects.xsd', 32, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    _ElementMap.update({
        __TM_PeriodDuration.name() : __TM_PeriodDuration
    })
    _AttributeMap.update({
        __nilReason.name() : __nilReason
    })
_module_typeBindings.TM_PeriodDuration_PropertyType = TM_PeriodDuration_PropertyType
_Namespace_gts.addCategoryObject('typeBinding', 'TM_PeriodDuration_PropertyType', TM_PeriodDuration_PropertyType)


# Complex type {http://www.opengis.net/gml/3.2}MeasureType with content type SIMPLE
class MeasureType (pyxb.binding.basis.complexTypeDefinition):
    """gml:MeasureType supports recording an amount encoded as a value of XML Schema double, together with a units of measure indicated by an attribute uom, short for "units Of measure". The value of the uom attribute identifies a reference system for the amount, usually a ratio or interval scale."""
    _TypeDefinition = pyxb.binding.datatypes.double
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_SIMPLE
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'MeasureType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/basicTypes.xsd', 113, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.double
    
    # Attribute uom uses Python identifier uom
    __uom = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'uom'), 'uom', '__httpwww_opengis_netgml3_2_MeasureType_uom', _module_typeBindings.UomIdentifier, required=True)
    __uom._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/basicTypes.xsd', 119, 4)
    __uom._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/basicTypes.xsd', 119, 4)
    
    uom = property(__uom.value, __uom.set, None, None)

    _ElementMap.update({
        
    })
    _AttributeMap.update({
        __uom.name() : __uom
    })
_module_typeBindings.MeasureType = MeasureType
_Namespace_gml.addCategoryObject('typeBinding', 'MeasureType', MeasureType)


# Complex type {http://www.opengis.net/gml/3.2}MeasureListType with content type SIMPLE
class MeasureListType (pyxb.binding.basis.complexTypeDefinition):
    """gml:MeasureListType provides for a list of quantities."""
    _TypeDefinition = doubleList
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_SIMPLE
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'MeasureListType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/basicTypes.xsd', 248, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is doubleList
    
    # Attribute uom uses Python identifier uom
    __uom = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'uom'), 'uom', '__httpwww_opengis_netgml3_2_MeasureListType_uom', _module_typeBindings.UomIdentifier, required=True)
    __uom._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/basicTypes.xsd', 254, 4)
    __uom._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/basicTypes.xsd', 254, 4)
    
    uom = property(__uom.value, __uom.set, None, None)

    _ElementMap.update({
        
    })
    _AttributeMap.update({
        __uom.name() : __uom
    })
_module_typeBindings.MeasureListType = MeasureListType
_Namespace_gml.addCategoryObject('typeBinding', 'MeasureListType', MeasureListType)


# Complex type [anonymous] with content type ELEMENT_ONLY
class CTD_ANON_6 (pyxb.binding.basis.complexTypeDefinition):
    """gml:coordinateOperationAccuracy is an association role to a DQ_PositionalAccuracy object as encoded in ISO/TS 19139, either referencing or containing the definition of that positional accuracy. That object contains an estimate of the impact of this coordinate operation on point accuracy. That is, it gives position error estimates for the target coordinates of this coordinate operation, assuming no errors in the source coordinates."""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = None
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 52, 2)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.isotc211.org/2005/gmd}AbstractDQ_PositionalAccuracy uses Python identifier AbstractDQ_PositionalAccuracy
    __AbstractDQ_PositionalAccuracy = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'AbstractDQ_PositionalAccuracy'), 'AbstractDQ_PositionalAccuracy', '__httpwww_opengis_netgml3_2_CTD_ANON_6_httpwww_isotc211_org2005gmdAbstractDQ_PositionalAccuracy', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 433, 1), )

    
    AbstractDQ_PositionalAccuracy = property(__AbstractDQ_PositionalAccuracy.value, __AbstractDQ_PositionalAccuracy.set, None, None)

    
    # Attribute {http://www.opengis.net/gml/3.2}remoteSchema uses Python identifier remoteSchema
    __remoteSchema = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gml, 'remoteSchema'), 'remoteSchema', '__httpwww_opengis_netgml3_2_CTD_ANON_6_httpwww_opengis_netgml3_2remoteSchema', pyxb.binding.datatypes.anyURI)
    __remoteSchema._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 638, 1)
    __remoteSchema._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 52, 2)
    
    remoteSchema = property(__remoteSchema.value, __remoteSchema.set, None, '')

    
    # Attribute nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'nilReason'), 'nilReason', '__httpwww_opengis_netgml3_2_CTD_ANON_6_nilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 51, 2)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 51, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}type uses Python identifier type
    __type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'type'), 'type', '__httpwww_opengis_netgml3_2_CTD_ANON_6_httpwww_w3_org1999xlinktype', _ImportedBinding_bindings_v1411_write__xlink.typeType, fixed=True, unicode_default='simple')
    __type._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 29, 1)
    __type._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 112, 2)
    
    type = property(__type.value, __type.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}href uses Python identifier href
    __href = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'href'), 'href', '__httpwww_opengis_netgml3_2_CTD_ANON_6_httpwww_w3_org1999xlinkhref', _ImportedBinding_bindings_v1411_write__xlink.hrefType)
    __href._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 42, 1)
    __href._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 113, 2)
    
    href = property(__href.value, __href.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}role uses Python identifier role
    __role = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'role'), 'role', '__httpwww_opengis_netgml3_2_CTD_ANON_6_httpwww_w3_org1999xlinkrole', _ImportedBinding_bindings_v1411_write__xlink.roleType)
    __role._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 48, 1)
    __role._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 114, 2)
    
    role = property(__role.value, __role.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}arcrole uses Python identifier arcrole
    __arcrole = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'arcrole'), 'arcrole', '__httpwww_opengis_netgml3_2_CTD_ANON_6_httpwww_w3_org1999xlinkarcrole', _ImportedBinding_bindings_v1411_write__xlink.arcroleType)
    __arcrole._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 56, 1)
    __arcrole._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 115, 2)
    
    arcrole = property(__arcrole.value, __arcrole.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}title uses Python identifier title
    __title = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'title'), 'title', '__httpwww_opengis_netgml3_2_CTD_ANON_6_httpwww_w3_org1999xlinktitle', _ImportedBinding_bindings_v1411_write__xlink.titleAttrType)
    __title._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 64, 1)
    __title._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 116, 2)
    
    title = property(__title.value, __title.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}show uses Python identifier show
    __show = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'show'), 'show', '__httpwww_opengis_netgml3_2_CTD_ANON_6_httpwww_w3_org1999xlinkshow', _ImportedBinding_bindings_v1411_write__xlink.showType)
    __show._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 70, 1)
    __show._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 117, 2)
    
    show = property(__show.value, __show.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}actuate uses Python identifier actuate
    __actuate = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'actuate'), 'actuate', '__httpwww_opengis_netgml3_2_CTD_ANON_6_httpwww_w3_org1999xlinkactuate', _ImportedBinding_bindings_v1411_write__xlink.actuateType)
    __actuate._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 82, 1)
    __actuate._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 118, 2)
    
    actuate = property(__actuate.value, __actuate.set, None, None)

    _ElementMap.update({
        __AbstractDQ_PositionalAccuracy.name() : __AbstractDQ_PositionalAccuracy
    })
    _AttributeMap.update({
        __remoteSchema.name() : __remoteSchema,
        __nilReason.name() : __nilReason,
        __type.name() : __type,
        __href.name() : __href,
        __role.name() : __role,
        __arcrole.name() : __arcrole,
        __title.name() : __title,
        __show.name() : __show,
        __actuate.name() : __actuate
    })
_module_typeBindings.CTD_ANON_6 = CTD_ANON_6


# Complex type {http://www.opengis.net/gml/3.2}CoordinateOperationPropertyType with content type ELEMENT_ONLY
class CoordinateOperationPropertyType (pyxb.binding.basis.complexTypeDefinition):
    """gml:CoordinateOperationPropertyType is a property type for association roles to a coordinate operation, either referencing or containing the definition of that coordinate operation."""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'CoordinateOperationPropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 69, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.opengis.net/gml/3.2}AbstractCoordinateOperation uses Python identifier AbstractCoordinateOperation
    __AbstractCoordinateOperation = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractCoordinateOperation'), 'AbstractCoordinateOperation', '__httpwww_opengis_netgml3_2_CoordinateOperationPropertyType_httpwww_opengis_netgml3_2AbstractCoordinateOperation', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 23, 1), )

    
    AbstractCoordinateOperation = property(__AbstractCoordinateOperation.value, __AbstractCoordinateOperation.set, None, 'gml:AbstractCoordinateOperation is a mathematical operation on coordinates that transforms or converts coordinates to another coordinate reference system. Many but not all coordinate operations (from CRS A to CRS B) also uniquely define the inverse operation (from CRS B to CRS A). In some cases, the operation method algorithm for the inverse operation is the same as for the forward algorithm, but the signs of some operation parameter values shall be reversed. In other cases, different algorithms are required for the forward and inverse operations, but the same operation parameter values are used. If (some) entirely different parameter values are needed, a different coordinate operation shall be defined.\nThe optional coordinateOperationAccuracy property elements provide estimates of the impact of this coordinate operation on point position accuracy.')

    
    # Attribute {http://www.opengis.net/gml/3.2}remoteSchema uses Python identifier remoteSchema
    __remoteSchema = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gml, 'remoteSchema'), 'remoteSchema', '__httpwww_opengis_netgml3_2_CoordinateOperationPropertyType_httpwww_opengis_netgml3_2remoteSchema', pyxb.binding.datatypes.anyURI)
    __remoteSchema._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 638, 1)
    __remoteSchema._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 52, 2)
    
    remoteSchema = property(__remoteSchema.value, __remoteSchema.set, None, '')

    
    # Attribute nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'nilReason'), 'nilReason', '__httpwww_opengis_netgml3_2_CoordinateOperationPropertyType_nilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 51, 2)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 51, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}type uses Python identifier type
    __type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'type'), 'type', '__httpwww_opengis_netgml3_2_CoordinateOperationPropertyType_httpwww_w3_org1999xlinktype', _ImportedBinding_bindings_v1411_write__xlink.typeType, fixed=True, unicode_default='simple')
    __type._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 29, 1)
    __type._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 112, 2)
    
    type = property(__type.value, __type.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}href uses Python identifier href
    __href = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'href'), 'href', '__httpwww_opengis_netgml3_2_CoordinateOperationPropertyType_httpwww_w3_org1999xlinkhref', _ImportedBinding_bindings_v1411_write__xlink.hrefType)
    __href._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 42, 1)
    __href._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 113, 2)
    
    href = property(__href.value, __href.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}role uses Python identifier role
    __role = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'role'), 'role', '__httpwww_opengis_netgml3_2_CoordinateOperationPropertyType_httpwww_w3_org1999xlinkrole', _ImportedBinding_bindings_v1411_write__xlink.roleType)
    __role._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 48, 1)
    __role._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 114, 2)
    
    role = property(__role.value, __role.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}arcrole uses Python identifier arcrole
    __arcrole = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'arcrole'), 'arcrole', '__httpwww_opengis_netgml3_2_CoordinateOperationPropertyType_httpwww_w3_org1999xlinkarcrole', _ImportedBinding_bindings_v1411_write__xlink.arcroleType)
    __arcrole._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 56, 1)
    __arcrole._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 115, 2)
    
    arcrole = property(__arcrole.value, __arcrole.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}title uses Python identifier title
    __title = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'title'), 'title', '__httpwww_opengis_netgml3_2_CoordinateOperationPropertyType_httpwww_w3_org1999xlinktitle', _ImportedBinding_bindings_v1411_write__xlink.titleAttrType)
    __title._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 64, 1)
    __title._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 116, 2)
    
    title = property(__title.value, __title.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}show uses Python identifier show
    __show = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'show'), 'show', '__httpwww_opengis_netgml3_2_CoordinateOperationPropertyType_httpwww_w3_org1999xlinkshow', _ImportedBinding_bindings_v1411_write__xlink.showType)
    __show._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 70, 1)
    __show._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 117, 2)
    
    show = property(__show.value, __show.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}actuate uses Python identifier actuate
    __actuate = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'actuate'), 'actuate', '__httpwww_opengis_netgml3_2_CoordinateOperationPropertyType_httpwww_w3_org1999xlinkactuate', _ImportedBinding_bindings_v1411_write__xlink.actuateType)
    __actuate._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 82, 1)
    __actuate._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 118, 2)
    
    actuate = property(__actuate.value, __actuate.set, None, None)

    _ElementMap.update({
        __AbstractCoordinateOperation.name() : __AbstractCoordinateOperation
    })
    _AttributeMap.update({
        __remoteSchema.name() : __remoteSchema,
        __nilReason.name() : __nilReason,
        __type.name() : __type,
        __href.name() : __href,
        __role.name() : __role,
        __arcrole.name() : __arcrole,
        __title.name() : __title,
        __show.name() : __show,
        __actuate.name() : __actuate
    })
_module_typeBindings.CoordinateOperationPropertyType = CoordinateOperationPropertyType
_Namespace_gml.addCategoryObject('typeBinding', 'CoordinateOperationPropertyType', CoordinateOperationPropertyType)


# Complex type {http://www.opengis.net/gml/3.2}SingleOperationPropertyType with content type ELEMENT_ONLY
class SingleOperationPropertyType (pyxb.binding.basis.complexTypeDefinition):
    """gml:SingleOperationPropertyType is a property type for association roles to a single operation, either referencing or containing the definition of that single operation."""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'SingleOperationPropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 83, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.opengis.net/gml/3.2}AbstractSingleOperation uses Python identifier AbstractSingleOperation
    __AbstractSingleOperation = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractSingleOperation'), 'AbstractSingleOperation', '__httpwww_opengis_netgml3_2_SingleOperationPropertyType_httpwww_opengis_netgml3_2AbstractSingleOperation', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 78, 1), )

    
    AbstractSingleOperation = property(__AbstractSingleOperation.value, __AbstractSingleOperation.set, None, 'gml:AbstractSingleOperation is a single (not concatenated) coordinate operation.')

    
    # Attribute {http://www.opengis.net/gml/3.2}remoteSchema uses Python identifier remoteSchema
    __remoteSchema = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gml, 'remoteSchema'), 'remoteSchema', '__httpwww_opengis_netgml3_2_SingleOperationPropertyType_httpwww_opengis_netgml3_2remoteSchema', pyxb.binding.datatypes.anyURI)
    __remoteSchema._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 638, 1)
    __remoteSchema._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 52, 2)
    
    remoteSchema = property(__remoteSchema.value, __remoteSchema.set, None, '')

    
    # Attribute nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'nilReason'), 'nilReason', '__httpwww_opengis_netgml3_2_SingleOperationPropertyType_nilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 51, 2)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 51, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}type uses Python identifier type
    __type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'type'), 'type', '__httpwww_opengis_netgml3_2_SingleOperationPropertyType_httpwww_w3_org1999xlinktype', _ImportedBinding_bindings_v1411_write__xlink.typeType, fixed=True, unicode_default='simple')
    __type._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 29, 1)
    __type._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 112, 2)
    
    type = property(__type.value, __type.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}href uses Python identifier href
    __href = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'href'), 'href', '__httpwww_opengis_netgml3_2_SingleOperationPropertyType_httpwww_w3_org1999xlinkhref', _ImportedBinding_bindings_v1411_write__xlink.hrefType)
    __href._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 42, 1)
    __href._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 113, 2)
    
    href = property(__href.value, __href.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}role uses Python identifier role
    __role = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'role'), 'role', '__httpwww_opengis_netgml3_2_SingleOperationPropertyType_httpwww_w3_org1999xlinkrole', _ImportedBinding_bindings_v1411_write__xlink.roleType)
    __role._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 48, 1)
    __role._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 114, 2)
    
    role = property(__role.value, __role.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}arcrole uses Python identifier arcrole
    __arcrole = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'arcrole'), 'arcrole', '__httpwww_opengis_netgml3_2_SingleOperationPropertyType_httpwww_w3_org1999xlinkarcrole', _ImportedBinding_bindings_v1411_write__xlink.arcroleType)
    __arcrole._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 56, 1)
    __arcrole._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 115, 2)
    
    arcrole = property(__arcrole.value, __arcrole.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}title uses Python identifier title
    __title = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'title'), 'title', '__httpwww_opengis_netgml3_2_SingleOperationPropertyType_httpwww_w3_org1999xlinktitle', _ImportedBinding_bindings_v1411_write__xlink.titleAttrType)
    __title._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 64, 1)
    __title._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 116, 2)
    
    title = property(__title.value, __title.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}show uses Python identifier show
    __show = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'show'), 'show', '__httpwww_opengis_netgml3_2_SingleOperationPropertyType_httpwww_w3_org1999xlinkshow', _ImportedBinding_bindings_v1411_write__xlink.showType)
    __show._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 70, 1)
    __show._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 117, 2)
    
    show = property(__show.value, __show.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}actuate uses Python identifier actuate
    __actuate = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'actuate'), 'actuate', '__httpwww_opengis_netgml3_2_SingleOperationPropertyType_httpwww_w3_org1999xlinkactuate', _ImportedBinding_bindings_v1411_write__xlink.actuateType)
    __actuate._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 82, 1)
    __actuate._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 118, 2)
    
    actuate = property(__actuate.value, __actuate.set, None, None)

    _ElementMap.update({
        __AbstractSingleOperation.name() : __AbstractSingleOperation
    })
    _AttributeMap.update({
        __remoteSchema.name() : __remoteSchema,
        __nilReason.name() : __nilReason,
        __type.name() : __type,
        __href.name() : __href,
        __role.name() : __role,
        __arcrole.name() : __arcrole,
        __title.name() : __title,
        __show.name() : __show,
        __actuate.name() : __actuate
    })
_module_typeBindings.SingleOperationPropertyType = SingleOperationPropertyType
_Namespace_gml.addCategoryObject('typeBinding', 'SingleOperationPropertyType', SingleOperationPropertyType)


# Complex type {http://www.opengis.net/gml/3.2}GeneralConversionPropertyType with content type ELEMENT_ONLY
class GeneralConversionPropertyType (pyxb.binding.basis.complexTypeDefinition):
    """gml:GeneralConversionPropertyType is a property type for association roles to a general conversion, either referencing or containing the definition of that conversion."""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'GeneralConversionPropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 116, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.opengis.net/gml/3.2}AbstractGeneralConversion uses Python identifier AbstractGeneralConversion
    __AbstractGeneralConversion = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractGeneralConversion'), 'AbstractGeneralConversion', '__httpwww_opengis_netgml3_2_GeneralConversionPropertyType_httpwww_opengis_netgml3_2AbstractGeneralConversion', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 92, 1), )

    
    AbstractGeneralConversion = property(__AbstractGeneralConversion.value, __AbstractGeneralConversion.set, None, 'gm:AbstractGeneralConversion is an abstract operation on coordinates that does not include any change of datum. The best-known example of a coordinate conversion is a map projection. The parameters describing coordinate conversions are defined rather than empirically derived. Note that some conversions have no parameters. The operationVersion, sourceCRS, and targetCRS elements are omitted in a coordinate conversion.\nThis abstract complex type is expected to be extended for well-known operation methods with many Conversion instances, in GML Application Schemas that define operation-method-specialized element names and contents. This conversion uses an operation method, usually with associated parameter values. However, operation methods and parameter values are directly associated with concrete subtypes, not with this abstract type. All concrete types derived from this type shall extend this type to include a "usesMethod" element that references the "OperationMethod" element. Similarly, all concrete types derived from this type shall extend this type to include zero or more elements each named "uses...Value" that each use the type of an element substitutable for the "AbstractGeneralParameterValue" element.')

    
    # Attribute {http://www.opengis.net/gml/3.2}remoteSchema uses Python identifier remoteSchema
    __remoteSchema = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gml, 'remoteSchema'), 'remoteSchema', '__httpwww_opengis_netgml3_2_GeneralConversionPropertyType_httpwww_opengis_netgml3_2remoteSchema', pyxb.binding.datatypes.anyURI)
    __remoteSchema._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 638, 1)
    __remoteSchema._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 52, 2)
    
    remoteSchema = property(__remoteSchema.value, __remoteSchema.set, None, '')

    
    # Attribute nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'nilReason'), 'nilReason', '__httpwww_opengis_netgml3_2_GeneralConversionPropertyType_nilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 51, 2)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 51, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}type uses Python identifier type
    __type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'type'), 'type', '__httpwww_opengis_netgml3_2_GeneralConversionPropertyType_httpwww_w3_org1999xlinktype', _ImportedBinding_bindings_v1411_write__xlink.typeType, fixed=True, unicode_default='simple')
    __type._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 29, 1)
    __type._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 112, 2)
    
    type = property(__type.value, __type.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}href uses Python identifier href
    __href = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'href'), 'href', '__httpwww_opengis_netgml3_2_GeneralConversionPropertyType_httpwww_w3_org1999xlinkhref', _ImportedBinding_bindings_v1411_write__xlink.hrefType)
    __href._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 42, 1)
    __href._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 113, 2)
    
    href = property(__href.value, __href.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}role uses Python identifier role
    __role = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'role'), 'role', '__httpwww_opengis_netgml3_2_GeneralConversionPropertyType_httpwww_w3_org1999xlinkrole', _ImportedBinding_bindings_v1411_write__xlink.roleType)
    __role._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 48, 1)
    __role._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 114, 2)
    
    role = property(__role.value, __role.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}arcrole uses Python identifier arcrole
    __arcrole = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'arcrole'), 'arcrole', '__httpwww_opengis_netgml3_2_GeneralConversionPropertyType_httpwww_w3_org1999xlinkarcrole', _ImportedBinding_bindings_v1411_write__xlink.arcroleType)
    __arcrole._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 56, 1)
    __arcrole._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 115, 2)
    
    arcrole = property(__arcrole.value, __arcrole.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}title uses Python identifier title
    __title = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'title'), 'title', '__httpwww_opengis_netgml3_2_GeneralConversionPropertyType_httpwww_w3_org1999xlinktitle', _ImportedBinding_bindings_v1411_write__xlink.titleAttrType)
    __title._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 64, 1)
    __title._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 116, 2)
    
    title = property(__title.value, __title.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}show uses Python identifier show
    __show = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'show'), 'show', '__httpwww_opengis_netgml3_2_GeneralConversionPropertyType_httpwww_w3_org1999xlinkshow', _ImportedBinding_bindings_v1411_write__xlink.showType)
    __show._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 70, 1)
    __show._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 117, 2)
    
    show = property(__show.value, __show.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}actuate uses Python identifier actuate
    __actuate = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'actuate'), 'actuate', '__httpwww_opengis_netgml3_2_GeneralConversionPropertyType_httpwww_w3_org1999xlinkactuate', _ImportedBinding_bindings_v1411_write__xlink.actuateType)
    __actuate._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 82, 1)
    __actuate._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 118, 2)
    
    actuate = property(__actuate.value, __actuate.set, None, None)

    _ElementMap.update({
        __AbstractGeneralConversion.name() : __AbstractGeneralConversion
    })
    _AttributeMap.update({
        __remoteSchema.name() : __remoteSchema,
        __nilReason.name() : __nilReason,
        __type.name() : __type,
        __href.name() : __href,
        __role.name() : __role,
        __arcrole.name() : __arcrole,
        __title.name() : __title,
        __show.name() : __show,
        __actuate.name() : __actuate
    })
_module_typeBindings.GeneralConversionPropertyType = GeneralConversionPropertyType
_Namespace_gml.addCategoryObject('typeBinding', 'GeneralConversionPropertyType', GeneralConversionPropertyType)


# Complex type {http://www.opengis.net/gml/3.2}GeneralTransformationPropertyType with content type ELEMENT_ONLY
class GeneralTransformationPropertyType (pyxb.binding.basis.complexTypeDefinition):
    """gml:GeneralTransformationPropertyType is a property type for association roles to a general transformation, either referencing or containing the definition of that transformation."""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'GeneralTransformationPropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 152, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.opengis.net/gml/3.2}AbstractGeneralTransformation uses Python identifier AbstractGeneralTransformation
    __AbstractGeneralTransformation = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractGeneralTransformation'), 'AbstractGeneralTransformation', '__httpwww_opengis_netgml3_2_GeneralTransformationPropertyType_httpwww_opengis_netgml3_2AbstractGeneralTransformation', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 125, 1), )

    
    AbstractGeneralTransformation = property(__AbstractGeneralTransformation.value, __AbstractGeneralTransformation.set, None, 'gml:AbstractGeneralTransformation is an abstract operation on coordinates that usually includes a change of Datum. The parameters of a coordinate transformation are empirically derived from data containing the coordinates of a series of points in both coordinate reference systems. This computational process is usually "over-determined", allowing derivation of error (or accuracy) estimates for the transformation. Also, the stochastic nature of the parameters may result in multiple (different) versions of the same coordinate transformation. The operationVersion, sourceCRS, and targetCRS proeprty elements are mandatory in a coordinate transformation.\nThis abstract complex type is expected to be extended for well-known operation methods with many Transformation instances, in Application Schemas that define operation-method-specialized value element names and contents. This transformation uses an operation method with associated parameter values. However, operation methods and parameter values are directly associated with concrete subtypes, not with this abstract type. All concrete types derived from this type shall extend this type to include a "usesMethod" element that references one "OperationMethod" element. Similarly, all concrete types derived from this type shall extend this type to include one or more elements each named "uses...Value" that each use the type of an element substitutable for the "AbstractGeneralParameterValue" element.')

    
    # Attribute {http://www.opengis.net/gml/3.2}remoteSchema uses Python identifier remoteSchema
    __remoteSchema = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gml, 'remoteSchema'), 'remoteSchema', '__httpwww_opengis_netgml3_2_GeneralTransformationPropertyType_httpwww_opengis_netgml3_2remoteSchema', pyxb.binding.datatypes.anyURI)
    __remoteSchema._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 638, 1)
    __remoteSchema._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 52, 2)
    
    remoteSchema = property(__remoteSchema.value, __remoteSchema.set, None, '')

    
    # Attribute nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'nilReason'), 'nilReason', '__httpwww_opengis_netgml3_2_GeneralTransformationPropertyType_nilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 51, 2)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 51, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}type uses Python identifier type
    __type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'type'), 'type', '__httpwww_opengis_netgml3_2_GeneralTransformationPropertyType_httpwww_w3_org1999xlinktype', _ImportedBinding_bindings_v1411_write__xlink.typeType, fixed=True, unicode_default='simple')
    __type._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 29, 1)
    __type._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 112, 2)
    
    type = property(__type.value, __type.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}href uses Python identifier href
    __href = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'href'), 'href', '__httpwww_opengis_netgml3_2_GeneralTransformationPropertyType_httpwww_w3_org1999xlinkhref', _ImportedBinding_bindings_v1411_write__xlink.hrefType)
    __href._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 42, 1)
    __href._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 113, 2)
    
    href = property(__href.value, __href.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}role uses Python identifier role
    __role = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'role'), 'role', '__httpwww_opengis_netgml3_2_GeneralTransformationPropertyType_httpwww_w3_org1999xlinkrole', _ImportedBinding_bindings_v1411_write__xlink.roleType)
    __role._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 48, 1)
    __role._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 114, 2)
    
    role = property(__role.value, __role.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}arcrole uses Python identifier arcrole
    __arcrole = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'arcrole'), 'arcrole', '__httpwww_opengis_netgml3_2_GeneralTransformationPropertyType_httpwww_w3_org1999xlinkarcrole', _ImportedBinding_bindings_v1411_write__xlink.arcroleType)
    __arcrole._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 56, 1)
    __arcrole._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 115, 2)
    
    arcrole = property(__arcrole.value, __arcrole.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}title uses Python identifier title
    __title = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'title'), 'title', '__httpwww_opengis_netgml3_2_GeneralTransformationPropertyType_httpwww_w3_org1999xlinktitle', _ImportedBinding_bindings_v1411_write__xlink.titleAttrType)
    __title._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 64, 1)
    __title._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 116, 2)
    
    title = property(__title.value, __title.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}show uses Python identifier show
    __show = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'show'), 'show', '__httpwww_opengis_netgml3_2_GeneralTransformationPropertyType_httpwww_w3_org1999xlinkshow', _ImportedBinding_bindings_v1411_write__xlink.showType)
    __show._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 70, 1)
    __show._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 117, 2)
    
    show = property(__show.value, __show.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}actuate uses Python identifier actuate
    __actuate = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'actuate'), 'actuate', '__httpwww_opengis_netgml3_2_GeneralTransformationPropertyType_httpwww_w3_org1999xlinkactuate', _ImportedBinding_bindings_v1411_write__xlink.actuateType)
    __actuate._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 82, 1)
    __actuate._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 118, 2)
    
    actuate = property(__actuate.value, __actuate.set, None, None)

    _ElementMap.update({
        __AbstractGeneralTransformation.name() : __AbstractGeneralTransformation
    })
    _AttributeMap.update({
        __remoteSchema.name() : __remoteSchema,
        __nilReason.name() : __nilReason,
        __type.name() : __type,
        __href.name() : __href,
        __role.name() : __role,
        __arcrole.name() : __arcrole,
        __title.name() : __title,
        __show.name() : __show,
        __actuate.name() : __actuate
    })
_module_typeBindings.GeneralTransformationPropertyType = GeneralTransformationPropertyType
_Namespace_gml.addCategoryObject('typeBinding', 'GeneralTransformationPropertyType', GeneralTransformationPropertyType)


# Complex type {http://www.opengis.net/gml/3.2}ConcatenatedOperationPropertyType with content type ELEMENT_ONLY
class ConcatenatedOperationPropertyType (pyxb.binding.basis.complexTypeDefinition):
    """gml:ConcatenatedOperationPropertyType is a property type for association roles to a concatenated operation, either referencing or containing the definition of that concatenated operation."""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'ConcatenatedOperationPropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 181, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.opengis.net/gml/3.2}ConcatenatedOperation uses Python identifier ConcatenatedOperation
    __ConcatenatedOperation = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'ConcatenatedOperation'), 'ConcatenatedOperation', '__httpwww_opengis_netgml3_2_ConcatenatedOperationPropertyType_httpwww_opengis_netgml3_2ConcatenatedOperation', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 161, 1), )

    
    ConcatenatedOperation = property(__ConcatenatedOperation.value, __ConcatenatedOperation.set, None, None)

    
    # Attribute {http://www.opengis.net/gml/3.2}remoteSchema uses Python identifier remoteSchema
    __remoteSchema = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gml, 'remoteSchema'), 'remoteSchema', '__httpwww_opengis_netgml3_2_ConcatenatedOperationPropertyType_httpwww_opengis_netgml3_2remoteSchema', pyxb.binding.datatypes.anyURI)
    __remoteSchema._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 638, 1)
    __remoteSchema._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 52, 2)
    
    remoteSchema = property(__remoteSchema.value, __remoteSchema.set, None, '')

    
    # Attribute nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'nilReason'), 'nilReason', '__httpwww_opengis_netgml3_2_ConcatenatedOperationPropertyType_nilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 51, 2)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 51, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}type uses Python identifier type
    __type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'type'), 'type', '__httpwww_opengis_netgml3_2_ConcatenatedOperationPropertyType_httpwww_w3_org1999xlinktype', _ImportedBinding_bindings_v1411_write__xlink.typeType, fixed=True, unicode_default='simple')
    __type._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 29, 1)
    __type._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 112, 2)
    
    type = property(__type.value, __type.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}href uses Python identifier href
    __href = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'href'), 'href', '__httpwww_opengis_netgml3_2_ConcatenatedOperationPropertyType_httpwww_w3_org1999xlinkhref', _ImportedBinding_bindings_v1411_write__xlink.hrefType)
    __href._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 42, 1)
    __href._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 113, 2)
    
    href = property(__href.value, __href.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}role uses Python identifier role
    __role = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'role'), 'role', '__httpwww_opengis_netgml3_2_ConcatenatedOperationPropertyType_httpwww_w3_org1999xlinkrole', _ImportedBinding_bindings_v1411_write__xlink.roleType)
    __role._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 48, 1)
    __role._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 114, 2)
    
    role = property(__role.value, __role.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}arcrole uses Python identifier arcrole
    __arcrole = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'arcrole'), 'arcrole', '__httpwww_opengis_netgml3_2_ConcatenatedOperationPropertyType_httpwww_w3_org1999xlinkarcrole', _ImportedBinding_bindings_v1411_write__xlink.arcroleType)
    __arcrole._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 56, 1)
    __arcrole._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 115, 2)
    
    arcrole = property(__arcrole.value, __arcrole.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}title uses Python identifier title
    __title = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'title'), 'title', '__httpwww_opengis_netgml3_2_ConcatenatedOperationPropertyType_httpwww_w3_org1999xlinktitle', _ImportedBinding_bindings_v1411_write__xlink.titleAttrType)
    __title._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 64, 1)
    __title._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 116, 2)
    
    title = property(__title.value, __title.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}show uses Python identifier show
    __show = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'show'), 'show', '__httpwww_opengis_netgml3_2_ConcatenatedOperationPropertyType_httpwww_w3_org1999xlinkshow', _ImportedBinding_bindings_v1411_write__xlink.showType)
    __show._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 70, 1)
    __show._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 117, 2)
    
    show = property(__show.value, __show.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}actuate uses Python identifier actuate
    __actuate = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'actuate'), 'actuate', '__httpwww_opengis_netgml3_2_ConcatenatedOperationPropertyType_httpwww_w3_org1999xlinkactuate', _ImportedBinding_bindings_v1411_write__xlink.actuateType)
    __actuate._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 82, 1)
    __actuate._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 118, 2)
    
    actuate = property(__actuate.value, __actuate.set, None, None)

    _ElementMap.update({
        __ConcatenatedOperation.name() : __ConcatenatedOperation
    })
    _AttributeMap.update({
        __remoteSchema.name() : __remoteSchema,
        __nilReason.name() : __nilReason,
        __type.name() : __type,
        __href.name() : __href,
        __role.name() : __role,
        __arcrole.name() : __arcrole,
        __title.name() : __title,
        __show.name() : __show,
        __actuate.name() : __actuate
    })
_module_typeBindings.ConcatenatedOperationPropertyType = ConcatenatedOperationPropertyType
_Namespace_gml.addCategoryObject('typeBinding', 'ConcatenatedOperationPropertyType', ConcatenatedOperationPropertyType)


# Complex type {http://www.opengis.net/gml/3.2}PassThroughOperationPropertyType with content type ELEMENT_ONLY
class PassThroughOperationPropertyType (pyxb.binding.basis.complexTypeDefinition):
    """gml:PassThroughOperationPropertyType is a property type for association roles to a pass through operation, either referencing or containing the definition of that pass through operation."""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'PassThroughOperationPropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 212, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.opengis.net/gml/3.2}PassThroughOperation uses Python identifier PassThroughOperation
    __PassThroughOperation = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'PassThroughOperation'), 'PassThroughOperation', '__httpwww_opengis_netgml3_2_PassThroughOperationPropertyType_httpwww_opengis_netgml3_2PassThroughOperation', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 190, 1), )

    
    PassThroughOperation = property(__PassThroughOperation.value, __PassThroughOperation.set, None, 'gml:PassThroughOperation is a pass-through operation specifies that a subset of a coordinate tuple is subject to a specific coordinate operation.\nThe modifiedCoordinate property elements are an ordered sequence of positive integers defining the positions in a coordinate tuple of the coordinates affected by this pass-through operation. The AggregationAttributeGroup should be used to specify that the modifiedCoordinate elements are ordered.')

    
    # Attribute {http://www.opengis.net/gml/3.2}remoteSchema uses Python identifier remoteSchema
    __remoteSchema = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gml, 'remoteSchema'), 'remoteSchema', '__httpwww_opengis_netgml3_2_PassThroughOperationPropertyType_httpwww_opengis_netgml3_2remoteSchema', pyxb.binding.datatypes.anyURI)
    __remoteSchema._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 638, 1)
    __remoteSchema._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 52, 2)
    
    remoteSchema = property(__remoteSchema.value, __remoteSchema.set, None, '')

    
    # Attribute nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'nilReason'), 'nilReason', '__httpwww_opengis_netgml3_2_PassThroughOperationPropertyType_nilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 51, 2)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 51, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}type uses Python identifier type
    __type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'type'), 'type', '__httpwww_opengis_netgml3_2_PassThroughOperationPropertyType_httpwww_w3_org1999xlinktype', _ImportedBinding_bindings_v1411_write__xlink.typeType, fixed=True, unicode_default='simple')
    __type._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 29, 1)
    __type._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 112, 2)
    
    type = property(__type.value, __type.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}href uses Python identifier href
    __href = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'href'), 'href', '__httpwww_opengis_netgml3_2_PassThroughOperationPropertyType_httpwww_w3_org1999xlinkhref', _ImportedBinding_bindings_v1411_write__xlink.hrefType)
    __href._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 42, 1)
    __href._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 113, 2)
    
    href = property(__href.value, __href.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}role uses Python identifier role
    __role = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'role'), 'role', '__httpwww_opengis_netgml3_2_PassThroughOperationPropertyType_httpwww_w3_org1999xlinkrole', _ImportedBinding_bindings_v1411_write__xlink.roleType)
    __role._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 48, 1)
    __role._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 114, 2)
    
    role = property(__role.value, __role.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}arcrole uses Python identifier arcrole
    __arcrole = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'arcrole'), 'arcrole', '__httpwww_opengis_netgml3_2_PassThroughOperationPropertyType_httpwww_w3_org1999xlinkarcrole', _ImportedBinding_bindings_v1411_write__xlink.arcroleType)
    __arcrole._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 56, 1)
    __arcrole._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 115, 2)
    
    arcrole = property(__arcrole.value, __arcrole.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}title uses Python identifier title
    __title = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'title'), 'title', '__httpwww_opengis_netgml3_2_PassThroughOperationPropertyType_httpwww_w3_org1999xlinktitle', _ImportedBinding_bindings_v1411_write__xlink.titleAttrType)
    __title._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 64, 1)
    __title._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 116, 2)
    
    title = property(__title.value, __title.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}show uses Python identifier show
    __show = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'show'), 'show', '__httpwww_opengis_netgml3_2_PassThroughOperationPropertyType_httpwww_w3_org1999xlinkshow', _ImportedBinding_bindings_v1411_write__xlink.showType)
    __show._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 70, 1)
    __show._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 117, 2)
    
    show = property(__show.value, __show.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}actuate uses Python identifier actuate
    __actuate = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'actuate'), 'actuate', '__httpwww_opengis_netgml3_2_PassThroughOperationPropertyType_httpwww_w3_org1999xlinkactuate', _ImportedBinding_bindings_v1411_write__xlink.actuateType)
    __actuate._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 82, 1)
    __actuate._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 118, 2)
    
    actuate = property(__actuate.value, __actuate.set, None, None)

    _ElementMap.update({
        __PassThroughOperation.name() : __PassThroughOperation
    })
    _AttributeMap.update({
        __remoteSchema.name() : __remoteSchema,
        __nilReason.name() : __nilReason,
        __type.name() : __type,
        __href.name() : __href,
        __role.name() : __role,
        __arcrole.name() : __arcrole,
        __title.name() : __title,
        __show.name() : __show,
        __actuate.name() : __actuate
    })
_module_typeBindings.PassThroughOperationPropertyType = PassThroughOperationPropertyType
_Namespace_gml.addCategoryObject('typeBinding', 'PassThroughOperationPropertyType', PassThroughOperationPropertyType)


# Complex type {http://www.opengis.net/gml/3.2}ConversionPropertyType with content type ELEMENT_ONLY
class ConversionPropertyType (pyxb.binding.basis.complexTypeDefinition):
    """gml:ConversionPropertyType is a property type for association roles to a concrete general-purpose conversion, either referencing or containing the definition of that conversion."""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'ConversionPropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 248, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.opengis.net/gml/3.2}Conversion uses Python identifier Conversion
    __Conversion = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'Conversion'), 'Conversion', '__httpwww_opengis_netgml3_2_ConversionPropertyType_httpwww_opengis_netgml3_2Conversion', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 221, 1), )

    
    Conversion = property(__Conversion.value, __Conversion.set, None, 'gml:Conversion is a concrete operation on coordinates that does not include any change of Datum. The best-known example of a coordinate conversion is a map projection. The parameters describing coordinate conversions are defined rather than empirically derived. Note that some conversions have no parameters.\nThis concrete complex type can be used without using a GML Application Schema that defines operation-method-specialized element names and contents, especially for methods with only one Conversion instance.\nThe usesValue property elements are an unordered list of composition associations to the set of parameter values used by this conversion operation.')

    
    # Attribute {http://www.opengis.net/gml/3.2}remoteSchema uses Python identifier remoteSchema
    __remoteSchema = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gml, 'remoteSchema'), 'remoteSchema', '__httpwww_opengis_netgml3_2_ConversionPropertyType_httpwww_opengis_netgml3_2remoteSchema', pyxb.binding.datatypes.anyURI)
    __remoteSchema._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 638, 1)
    __remoteSchema._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 52, 2)
    
    remoteSchema = property(__remoteSchema.value, __remoteSchema.set, None, '')

    
    # Attribute nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'nilReason'), 'nilReason', '__httpwww_opengis_netgml3_2_ConversionPropertyType_nilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 51, 2)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 51, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}type uses Python identifier type
    __type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'type'), 'type', '__httpwww_opengis_netgml3_2_ConversionPropertyType_httpwww_w3_org1999xlinktype', _ImportedBinding_bindings_v1411_write__xlink.typeType, fixed=True, unicode_default='simple')
    __type._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 29, 1)
    __type._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 112, 2)
    
    type = property(__type.value, __type.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}href uses Python identifier href
    __href = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'href'), 'href', '__httpwww_opengis_netgml3_2_ConversionPropertyType_httpwww_w3_org1999xlinkhref', _ImportedBinding_bindings_v1411_write__xlink.hrefType)
    __href._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 42, 1)
    __href._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 113, 2)
    
    href = property(__href.value, __href.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}role uses Python identifier role
    __role = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'role'), 'role', '__httpwww_opengis_netgml3_2_ConversionPropertyType_httpwww_w3_org1999xlinkrole', _ImportedBinding_bindings_v1411_write__xlink.roleType)
    __role._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 48, 1)
    __role._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 114, 2)
    
    role = property(__role.value, __role.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}arcrole uses Python identifier arcrole
    __arcrole = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'arcrole'), 'arcrole', '__httpwww_opengis_netgml3_2_ConversionPropertyType_httpwww_w3_org1999xlinkarcrole', _ImportedBinding_bindings_v1411_write__xlink.arcroleType)
    __arcrole._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 56, 1)
    __arcrole._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 115, 2)
    
    arcrole = property(__arcrole.value, __arcrole.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}title uses Python identifier title
    __title = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'title'), 'title', '__httpwww_opengis_netgml3_2_ConversionPropertyType_httpwww_w3_org1999xlinktitle', _ImportedBinding_bindings_v1411_write__xlink.titleAttrType)
    __title._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 64, 1)
    __title._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 116, 2)
    
    title = property(__title.value, __title.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}show uses Python identifier show
    __show = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'show'), 'show', '__httpwww_opengis_netgml3_2_ConversionPropertyType_httpwww_w3_org1999xlinkshow', _ImportedBinding_bindings_v1411_write__xlink.showType)
    __show._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 70, 1)
    __show._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 117, 2)
    
    show = property(__show.value, __show.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}actuate uses Python identifier actuate
    __actuate = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'actuate'), 'actuate', '__httpwww_opengis_netgml3_2_ConversionPropertyType_httpwww_w3_org1999xlinkactuate', _ImportedBinding_bindings_v1411_write__xlink.actuateType)
    __actuate._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 82, 1)
    __actuate._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 118, 2)
    
    actuate = property(__actuate.value, __actuate.set, None, None)

    _ElementMap.update({
        __Conversion.name() : __Conversion
    })
    _AttributeMap.update({
        __remoteSchema.name() : __remoteSchema,
        __nilReason.name() : __nilReason,
        __type.name() : __type,
        __href.name() : __href,
        __role.name() : __role,
        __arcrole.name() : __arcrole,
        __title.name() : __title,
        __show.name() : __show,
        __actuate.name() : __actuate
    })
_module_typeBindings.ConversionPropertyType = ConversionPropertyType
_Namespace_gml.addCategoryObject('typeBinding', 'ConversionPropertyType', ConversionPropertyType)


# Complex type {http://www.opengis.net/gml/3.2}TransformationPropertyType with content type ELEMENT_ONLY
class TransformationPropertyType (pyxb.binding.basis.complexTypeDefinition):
    """gml:TransformationPropertyType is a property type for association roles to a transformation, either referencing or containing the definition of that transformation."""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'TransformationPropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 274, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.opengis.net/gml/3.2}Transformation uses Python identifier Transformation
    __Transformation = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'Transformation'), 'Transformation', '__httpwww_opengis_netgml3_2_TransformationPropertyType_httpwww_opengis_netgml3_2Transformation', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 257, 1), )

    
    Transformation = property(__Transformation.value, __Transformation.set, None, 'gml:Transformation is a concrete object element derived from gml:GeneralTransformation (13.6.2.13).\nThis concrete object can be used for all operation methods, without using a GML Application Schema that defines operation-method-specialized element names and contents, especially for methods with only one Transformation instance.\nThe parameterValue elements are an unordered list of composition associations to the set of parameter values used by this conversion operation.')

    
    # Attribute {http://www.opengis.net/gml/3.2}remoteSchema uses Python identifier remoteSchema
    __remoteSchema = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gml, 'remoteSchema'), 'remoteSchema', '__httpwww_opengis_netgml3_2_TransformationPropertyType_httpwww_opengis_netgml3_2remoteSchema', pyxb.binding.datatypes.anyURI)
    __remoteSchema._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 638, 1)
    __remoteSchema._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 52, 2)
    
    remoteSchema = property(__remoteSchema.value, __remoteSchema.set, None, '')

    
    # Attribute nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'nilReason'), 'nilReason', '__httpwww_opengis_netgml3_2_TransformationPropertyType_nilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 51, 2)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 51, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}type uses Python identifier type
    __type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'type'), 'type', '__httpwww_opengis_netgml3_2_TransformationPropertyType_httpwww_w3_org1999xlinktype', _ImportedBinding_bindings_v1411_write__xlink.typeType, fixed=True, unicode_default='simple')
    __type._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 29, 1)
    __type._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 112, 2)
    
    type = property(__type.value, __type.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}href uses Python identifier href
    __href = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'href'), 'href', '__httpwww_opengis_netgml3_2_TransformationPropertyType_httpwww_w3_org1999xlinkhref', _ImportedBinding_bindings_v1411_write__xlink.hrefType)
    __href._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 42, 1)
    __href._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 113, 2)
    
    href = property(__href.value, __href.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}role uses Python identifier role
    __role = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'role'), 'role', '__httpwww_opengis_netgml3_2_TransformationPropertyType_httpwww_w3_org1999xlinkrole', _ImportedBinding_bindings_v1411_write__xlink.roleType)
    __role._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 48, 1)
    __role._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 114, 2)
    
    role = property(__role.value, __role.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}arcrole uses Python identifier arcrole
    __arcrole = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'arcrole'), 'arcrole', '__httpwww_opengis_netgml3_2_TransformationPropertyType_httpwww_w3_org1999xlinkarcrole', _ImportedBinding_bindings_v1411_write__xlink.arcroleType)
    __arcrole._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 56, 1)
    __arcrole._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 115, 2)
    
    arcrole = property(__arcrole.value, __arcrole.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}title uses Python identifier title
    __title = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'title'), 'title', '__httpwww_opengis_netgml3_2_TransformationPropertyType_httpwww_w3_org1999xlinktitle', _ImportedBinding_bindings_v1411_write__xlink.titleAttrType)
    __title._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 64, 1)
    __title._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 116, 2)
    
    title = property(__title.value, __title.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}show uses Python identifier show
    __show = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'show'), 'show', '__httpwww_opengis_netgml3_2_TransformationPropertyType_httpwww_w3_org1999xlinkshow', _ImportedBinding_bindings_v1411_write__xlink.showType)
    __show._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 70, 1)
    __show._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 117, 2)
    
    show = property(__show.value, __show.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}actuate uses Python identifier actuate
    __actuate = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'actuate'), 'actuate', '__httpwww_opengis_netgml3_2_TransformationPropertyType_httpwww_w3_org1999xlinkactuate', _ImportedBinding_bindings_v1411_write__xlink.actuateType)
    __actuate._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 82, 1)
    __actuate._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 118, 2)
    
    actuate = property(__actuate.value, __actuate.set, None, None)

    _ElementMap.update({
        __Transformation.name() : __Transformation
    })
    _AttributeMap.update({
        __remoteSchema.name() : __remoteSchema,
        __nilReason.name() : __nilReason,
        __type.name() : __type,
        __href.name() : __href,
        __role.name() : __role,
        __arcrole.name() : __arcrole,
        __title.name() : __title,
        __show.name() : __show,
        __actuate.name() : __actuate
    })
_module_typeBindings.TransformationPropertyType = TransformationPropertyType
_Namespace_gml.addCategoryObject('typeBinding', 'TransformationPropertyType', TransformationPropertyType)


# Complex type [anonymous] with content type ELEMENT_ONLY
class CTD_ANON_7 (pyxb.binding.basis.complexTypeDefinition):
    """gml:formulaCitation provides a reference to a publication giving the formula(s) or procedure used by an coordinate operation method."""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = None
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 410, 2)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.isotc211.org/2005/gmd}CI_Citation uses Python identifier CI_Citation
    __CI_Citation = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'CI_Citation'), 'CI_Citation', '__httpwww_opengis_netgml3_2_CTD_ANON_7_httpwww_isotc211_org2005gmdCI_Citation', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 66, 1), )

    
    CI_Citation = property(__CI_Citation.value, __CI_Citation.set, None, None)

    
    # Attribute {http://www.opengis.net/gml/3.2}remoteSchema uses Python identifier remoteSchema
    __remoteSchema = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gml, 'remoteSchema'), 'remoteSchema', '__httpwww_opengis_netgml3_2_CTD_ANON_7_httpwww_opengis_netgml3_2remoteSchema', pyxb.binding.datatypes.anyURI)
    __remoteSchema._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 638, 1)
    __remoteSchema._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 52, 2)
    
    remoteSchema = property(__remoteSchema.value, __remoteSchema.set, None, '')

    
    # Attribute nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'nilReason'), 'nilReason', '__httpwww_opengis_netgml3_2_CTD_ANON_7_nilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 51, 2)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 51, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}type uses Python identifier type
    __type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'type'), 'type', '__httpwww_opengis_netgml3_2_CTD_ANON_7_httpwww_w3_org1999xlinktype', _ImportedBinding_bindings_v1411_write__xlink.typeType, fixed=True, unicode_default='simple')
    __type._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 29, 1)
    __type._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 112, 2)
    
    type = property(__type.value, __type.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}href uses Python identifier href
    __href = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'href'), 'href', '__httpwww_opengis_netgml3_2_CTD_ANON_7_httpwww_w3_org1999xlinkhref', _ImportedBinding_bindings_v1411_write__xlink.hrefType)
    __href._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 42, 1)
    __href._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 113, 2)
    
    href = property(__href.value, __href.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}role uses Python identifier role
    __role = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'role'), 'role', '__httpwww_opengis_netgml3_2_CTD_ANON_7_httpwww_w3_org1999xlinkrole', _ImportedBinding_bindings_v1411_write__xlink.roleType)
    __role._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 48, 1)
    __role._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 114, 2)
    
    role = property(__role.value, __role.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}arcrole uses Python identifier arcrole
    __arcrole = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'arcrole'), 'arcrole', '__httpwww_opengis_netgml3_2_CTD_ANON_7_httpwww_w3_org1999xlinkarcrole', _ImportedBinding_bindings_v1411_write__xlink.arcroleType)
    __arcrole._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 56, 1)
    __arcrole._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 115, 2)
    
    arcrole = property(__arcrole.value, __arcrole.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}title uses Python identifier title
    __title = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'title'), 'title', '__httpwww_opengis_netgml3_2_CTD_ANON_7_httpwww_w3_org1999xlinktitle', _ImportedBinding_bindings_v1411_write__xlink.titleAttrType)
    __title._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 64, 1)
    __title._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 116, 2)
    
    title = property(__title.value, __title.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}show uses Python identifier show
    __show = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'show'), 'show', '__httpwww_opengis_netgml3_2_CTD_ANON_7_httpwww_w3_org1999xlinkshow', _ImportedBinding_bindings_v1411_write__xlink.showType)
    __show._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 70, 1)
    __show._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 117, 2)
    
    show = property(__show.value, __show.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}actuate uses Python identifier actuate
    __actuate = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'actuate'), 'actuate', '__httpwww_opengis_netgml3_2_CTD_ANON_7_httpwww_w3_org1999xlinkactuate', _ImportedBinding_bindings_v1411_write__xlink.actuateType)
    __actuate._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 82, 1)
    __actuate._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 118, 2)
    
    actuate = property(__actuate.value, __actuate.set, None, None)

    _ElementMap.update({
        __CI_Citation.name() : __CI_Citation
    })
    _AttributeMap.update({
        __remoteSchema.name() : __remoteSchema,
        __nilReason.name() : __nilReason,
        __type.name() : __type,
        __href.name() : __href,
        __role.name() : __role,
        __arcrole.name() : __arcrole,
        __title.name() : __title,
        __show.name() : __show,
        __actuate.name() : __actuate
    })
_module_typeBindings.CTD_ANON_7 = CTD_ANON_7


# Complex type {http://www.opengis.net/gml/3.2}OperationMethodPropertyType with content type ELEMENT_ONLY
class OperationMethodPropertyType (pyxb.binding.basis.complexTypeDefinition):
    """gml:OperationMethodPropertyType is a property type for association roles to a concrete general-purpose operation method, either referencing or containing the definition of that method."""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'OperationMethodPropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 437, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.opengis.net/gml/3.2}OperationMethod uses Python identifier OperationMethod
    __OperationMethod = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'OperationMethod'), 'OperationMethod', '__httpwww_opengis_netgml3_2_OperationMethodPropertyType_httpwww_opengis_netgml3_2OperationMethod', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 385, 1), )

    
    OperationMethod = property(__OperationMethod.value, __OperationMethod.set, None, 'gml:OperationMethod is a method (algorithm or procedure) used to perform a coordinate operation. Most operation methods use a number of operation parameters, although some coordinate conversions use none. Each coordinate operation using the method assigns values to these parameters.\nThe parameter elements are an unordered list of associations to the set of operation parameters and parameter groups used by this operation method.')

    
    # Attribute {http://www.opengis.net/gml/3.2}remoteSchema uses Python identifier remoteSchema
    __remoteSchema = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gml, 'remoteSchema'), 'remoteSchema', '__httpwww_opengis_netgml3_2_OperationMethodPropertyType_httpwww_opengis_netgml3_2remoteSchema', pyxb.binding.datatypes.anyURI)
    __remoteSchema._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 638, 1)
    __remoteSchema._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 52, 2)
    
    remoteSchema = property(__remoteSchema.value, __remoteSchema.set, None, '')

    
    # Attribute nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'nilReason'), 'nilReason', '__httpwww_opengis_netgml3_2_OperationMethodPropertyType_nilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 51, 2)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 51, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}type uses Python identifier type
    __type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'type'), 'type', '__httpwww_opengis_netgml3_2_OperationMethodPropertyType_httpwww_w3_org1999xlinktype', _ImportedBinding_bindings_v1411_write__xlink.typeType, fixed=True, unicode_default='simple')
    __type._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 29, 1)
    __type._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 112, 2)
    
    type = property(__type.value, __type.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}href uses Python identifier href
    __href = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'href'), 'href', '__httpwww_opengis_netgml3_2_OperationMethodPropertyType_httpwww_w3_org1999xlinkhref', _ImportedBinding_bindings_v1411_write__xlink.hrefType)
    __href._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 42, 1)
    __href._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 113, 2)
    
    href = property(__href.value, __href.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}role uses Python identifier role
    __role = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'role'), 'role', '__httpwww_opengis_netgml3_2_OperationMethodPropertyType_httpwww_w3_org1999xlinkrole', _ImportedBinding_bindings_v1411_write__xlink.roleType)
    __role._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 48, 1)
    __role._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 114, 2)
    
    role = property(__role.value, __role.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}arcrole uses Python identifier arcrole
    __arcrole = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'arcrole'), 'arcrole', '__httpwww_opengis_netgml3_2_OperationMethodPropertyType_httpwww_w3_org1999xlinkarcrole', _ImportedBinding_bindings_v1411_write__xlink.arcroleType)
    __arcrole._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 56, 1)
    __arcrole._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 115, 2)
    
    arcrole = property(__arcrole.value, __arcrole.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}title uses Python identifier title
    __title = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'title'), 'title', '__httpwww_opengis_netgml3_2_OperationMethodPropertyType_httpwww_w3_org1999xlinktitle', _ImportedBinding_bindings_v1411_write__xlink.titleAttrType)
    __title._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 64, 1)
    __title._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 116, 2)
    
    title = property(__title.value, __title.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}show uses Python identifier show
    __show = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'show'), 'show', '__httpwww_opengis_netgml3_2_OperationMethodPropertyType_httpwww_w3_org1999xlinkshow', _ImportedBinding_bindings_v1411_write__xlink.showType)
    __show._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 70, 1)
    __show._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 117, 2)
    
    show = property(__show.value, __show.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}actuate uses Python identifier actuate
    __actuate = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'actuate'), 'actuate', '__httpwww_opengis_netgml3_2_OperationMethodPropertyType_httpwww_w3_org1999xlinkactuate', _ImportedBinding_bindings_v1411_write__xlink.actuateType)
    __actuate._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 82, 1)
    __actuate._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 118, 2)
    
    actuate = property(__actuate.value, __actuate.set, None, None)

    _ElementMap.update({
        __OperationMethod.name() : __OperationMethod
    })
    _AttributeMap.update({
        __remoteSchema.name() : __remoteSchema,
        __nilReason.name() : __nilReason,
        __type.name() : __type,
        __href.name() : __href,
        __role.name() : __role,
        __arcrole.name() : __arcrole,
        __title.name() : __title,
        __show.name() : __show,
        __actuate.name() : __actuate
    })
_module_typeBindings.OperationMethodPropertyType = OperationMethodPropertyType
_Namespace_gml.addCategoryObject('typeBinding', 'OperationMethodPropertyType', OperationMethodPropertyType)


# Complex type {http://www.opengis.net/gml/3.2}AbstractGeneralOperationParameterPropertyType with content type ELEMENT_ONLY
class AbstractGeneralOperationParameterPropertyType (pyxb.binding.basis.complexTypeDefinition):
    """gml:AbstractGeneralOperationParameterPropertyType is a property type for association roles to an operation parameter or group, either referencing or containing the definition of that parameter or group."""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractGeneralOperationParameterPropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 465, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.opengis.net/gml/3.2}AbstractGeneralOperationParameter uses Python identifier AbstractGeneralOperationParameter
    __AbstractGeneralOperationParameter = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractGeneralOperationParameter'), 'AbstractGeneralOperationParameter', '__httpwww_opengis_netgml3_2_AbstractGeneralOperationParameterPropertyType_httpwww_opengis_netgml3_2AbstractGeneralOperationParameter', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 446, 1), )

    
    AbstractGeneralOperationParameter = property(__AbstractGeneralOperationParameter.value, __AbstractGeneralOperationParameter.set, None, 'gml:GeneralOperationParameter is the abstract definition of a parameter or group of parameters used by an operation method.')

    
    # Attribute {http://www.opengis.net/gml/3.2}remoteSchema uses Python identifier remoteSchema
    __remoteSchema = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gml, 'remoteSchema'), 'remoteSchema', '__httpwww_opengis_netgml3_2_AbstractGeneralOperationParameterPropertyType_httpwww_opengis_netgml3_2remoteSchema', pyxb.binding.datatypes.anyURI)
    __remoteSchema._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 638, 1)
    __remoteSchema._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 52, 2)
    
    remoteSchema = property(__remoteSchema.value, __remoteSchema.set, None, '')

    
    # Attribute nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'nilReason'), 'nilReason', '__httpwww_opengis_netgml3_2_AbstractGeneralOperationParameterPropertyType_nilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 51, 2)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 51, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}type uses Python identifier type
    __type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'type'), 'type', '__httpwww_opengis_netgml3_2_AbstractGeneralOperationParameterPropertyType_httpwww_w3_org1999xlinktype', _ImportedBinding_bindings_v1411_write__xlink.typeType, fixed=True, unicode_default='simple')
    __type._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 29, 1)
    __type._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 112, 2)
    
    type = property(__type.value, __type.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}href uses Python identifier href
    __href = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'href'), 'href', '__httpwww_opengis_netgml3_2_AbstractGeneralOperationParameterPropertyType_httpwww_w3_org1999xlinkhref', _ImportedBinding_bindings_v1411_write__xlink.hrefType)
    __href._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 42, 1)
    __href._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 113, 2)
    
    href = property(__href.value, __href.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}role uses Python identifier role
    __role = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'role'), 'role', '__httpwww_opengis_netgml3_2_AbstractGeneralOperationParameterPropertyType_httpwww_w3_org1999xlinkrole', _ImportedBinding_bindings_v1411_write__xlink.roleType)
    __role._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 48, 1)
    __role._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 114, 2)
    
    role = property(__role.value, __role.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}arcrole uses Python identifier arcrole
    __arcrole = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'arcrole'), 'arcrole', '__httpwww_opengis_netgml3_2_AbstractGeneralOperationParameterPropertyType_httpwww_w3_org1999xlinkarcrole', _ImportedBinding_bindings_v1411_write__xlink.arcroleType)
    __arcrole._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 56, 1)
    __arcrole._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 115, 2)
    
    arcrole = property(__arcrole.value, __arcrole.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}title uses Python identifier title
    __title = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'title'), 'title', '__httpwww_opengis_netgml3_2_AbstractGeneralOperationParameterPropertyType_httpwww_w3_org1999xlinktitle', _ImportedBinding_bindings_v1411_write__xlink.titleAttrType)
    __title._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 64, 1)
    __title._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 116, 2)
    
    title = property(__title.value, __title.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}show uses Python identifier show
    __show = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'show'), 'show', '__httpwww_opengis_netgml3_2_AbstractGeneralOperationParameterPropertyType_httpwww_w3_org1999xlinkshow', _ImportedBinding_bindings_v1411_write__xlink.showType)
    __show._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 70, 1)
    __show._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 117, 2)
    
    show = property(__show.value, __show.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}actuate uses Python identifier actuate
    __actuate = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'actuate'), 'actuate', '__httpwww_opengis_netgml3_2_AbstractGeneralOperationParameterPropertyType_httpwww_w3_org1999xlinkactuate', _ImportedBinding_bindings_v1411_write__xlink.actuateType)
    __actuate._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 82, 1)
    __actuate._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 118, 2)
    
    actuate = property(__actuate.value, __actuate.set, None, None)

    _ElementMap.update({
        __AbstractGeneralOperationParameter.name() : __AbstractGeneralOperationParameter
    })
    _AttributeMap.update({
        __remoteSchema.name() : __remoteSchema,
        __nilReason.name() : __nilReason,
        __type.name() : __type,
        __href.name() : __href,
        __role.name() : __role,
        __arcrole.name() : __arcrole,
        __title.name() : __title,
        __show.name() : __show,
        __actuate.name() : __actuate
    })
_module_typeBindings.AbstractGeneralOperationParameterPropertyType = AbstractGeneralOperationParameterPropertyType
_Namespace_gml.addCategoryObject('typeBinding', 'AbstractGeneralOperationParameterPropertyType', AbstractGeneralOperationParameterPropertyType)


# Complex type {http://www.opengis.net/gml/3.2}OperationParameterPropertyType with content type ELEMENT_ONLY
class OperationParameterPropertyType (pyxb.binding.basis.complexTypeDefinition):
    """gml:OperationParameterPropertyType is a property type for association roles to an operation parameter, either referencing or containing the definition of that parameter."""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'OperationParameterPropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 486, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.opengis.net/gml/3.2}OperationParameter uses Python identifier OperationParameter
    __OperationParameter = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'OperationParameter'), 'OperationParameter', '__httpwww_opengis_netgml3_2_OperationParameterPropertyType_httpwww_opengis_netgml3_2OperationParameter', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 474, 1), )

    
    OperationParameter = property(__OperationParameter.value, __OperationParameter.set, None, 'gml:OperationParameter is the definition of a parameter used by an operation method. Most parameter values are numeric, but other types of parameter values are possible. This complex type is expected to be used or extended for all operation methods, without defining operation-method-specialized element names.')

    
    # Attribute {http://www.opengis.net/gml/3.2}remoteSchema uses Python identifier remoteSchema
    __remoteSchema = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gml, 'remoteSchema'), 'remoteSchema', '__httpwww_opengis_netgml3_2_OperationParameterPropertyType_httpwww_opengis_netgml3_2remoteSchema', pyxb.binding.datatypes.anyURI)
    __remoteSchema._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 638, 1)
    __remoteSchema._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 52, 2)
    
    remoteSchema = property(__remoteSchema.value, __remoteSchema.set, None, '')

    
    # Attribute nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'nilReason'), 'nilReason', '__httpwww_opengis_netgml3_2_OperationParameterPropertyType_nilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 51, 2)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 51, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}type uses Python identifier type
    __type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'type'), 'type', '__httpwww_opengis_netgml3_2_OperationParameterPropertyType_httpwww_w3_org1999xlinktype', _ImportedBinding_bindings_v1411_write__xlink.typeType, fixed=True, unicode_default='simple')
    __type._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 29, 1)
    __type._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 112, 2)
    
    type = property(__type.value, __type.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}href uses Python identifier href
    __href = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'href'), 'href', '__httpwww_opengis_netgml3_2_OperationParameterPropertyType_httpwww_w3_org1999xlinkhref', _ImportedBinding_bindings_v1411_write__xlink.hrefType)
    __href._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 42, 1)
    __href._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 113, 2)
    
    href = property(__href.value, __href.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}role uses Python identifier role
    __role = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'role'), 'role', '__httpwww_opengis_netgml3_2_OperationParameterPropertyType_httpwww_w3_org1999xlinkrole', _ImportedBinding_bindings_v1411_write__xlink.roleType)
    __role._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 48, 1)
    __role._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 114, 2)
    
    role = property(__role.value, __role.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}arcrole uses Python identifier arcrole
    __arcrole = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'arcrole'), 'arcrole', '__httpwww_opengis_netgml3_2_OperationParameterPropertyType_httpwww_w3_org1999xlinkarcrole', _ImportedBinding_bindings_v1411_write__xlink.arcroleType)
    __arcrole._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 56, 1)
    __arcrole._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 115, 2)
    
    arcrole = property(__arcrole.value, __arcrole.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}title uses Python identifier title
    __title = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'title'), 'title', '__httpwww_opengis_netgml3_2_OperationParameterPropertyType_httpwww_w3_org1999xlinktitle', _ImportedBinding_bindings_v1411_write__xlink.titleAttrType)
    __title._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 64, 1)
    __title._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 116, 2)
    
    title = property(__title.value, __title.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}show uses Python identifier show
    __show = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'show'), 'show', '__httpwww_opengis_netgml3_2_OperationParameterPropertyType_httpwww_w3_org1999xlinkshow', _ImportedBinding_bindings_v1411_write__xlink.showType)
    __show._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 70, 1)
    __show._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 117, 2)
    
    show = property(__show.value, __show.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}actuate uses Python identifier actuate
    __actuate = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'actuate'), 'actuate', '__httpwww_opengis_netgml3_2_OperationParameterPropertyType_httpwww_w3_org1999xlinkactuate', _ImportedBinding_bindings_v1411_write__xlink.actuateType)
    __actuate._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 82, 1)
    __actuate._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 118, 2)
    
    actuate = property(__actuate.value, __actuate.set, None, None)

    _ElementMap.update({
        __OperationParameter.name() : __OperationParameter
    })
    _AttributeMap.update({
        __remoteSchema.name() : __remoteSchema,
        __nilReason.name() : __nilReason,
        __type.name() : __type,
        __href.name() : __href,
        __role.name() : __role,
        __arcrole.name() : __arcrole,
        __title.name() : __title,
        __show.name() : __show,
        __actuate.name() : __actuate
    })
_module_typeBindings.OperationParameterPropertyType = OperationParameterPropertyType
_Namespace_gml.addCategoryObject('typeBinding', 'OperationParameterPropertyType', OperationParameterPropertyType)


# Complex type {http://www.opengis.net/gml/3.2}OperationParameterGroupPropertyType with content type ELEMENT_ONLY
class OperationParameterGroupPropertyType (pyxb.binding.basis.complexTypeDefinition):
    """gml:OperationParameterPropertyType is a property type for association roles to an operation parameter group, either referencing or containing the definition of that parameter group."""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'OperationParameterGroupPropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 516, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.opengis.net/gml/3.2}OperationParameterGroup uses Python identifier OperationParameterGroup
    __OperationParameterGroup = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'OperationParameterGroup'), 'OperationParameterGroup', '__httpwww_opengis_netgml3_2_OperationParameterGroupPropertyType_httpwww_opengis_netgml3_2OperationParameterGroup', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 495, 1), )

    
    OperationParameterGroup = property(__OperationParameterGroup.value, __OperationParameterGroup.set, None, 'gml:OperationParameterGroup is the definition of a group of parameters used by an operation method. This complex type is expected to be used or extended for all applicable operation methods, without defining operation-method-specialized element names.\nThe generalOperationParameter elements are an unordered list of associations to the set of operation parameters that are members of this group.')

    
    # Attribute {http://www.opengis.net/gml/3.2}remoteSchema uses Python identifier remoteSchema
    __remoteSchema = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gml, 'remoteSchema'), 'remoteSchema', '__httpwww_opengis_netgml3_2_OperationParameterGroupPropertyType_httpwww_opengis_netgml3_2remoteSchema', pyxb.binding.datatypes.anyURI)
    __remoteSchema._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 638, 1)
    __remoteSchema._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 52, 2)
    
    remoteSchema = property(__remoteSchema.value, __remoteSchema.set, None, '')

    
    # Attribute nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'nilReason'), 'nilReason', '__httpwww_opengis_netgml3_2_OperationParameterGroupPropertyType_nilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 51, 2)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 51, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}type uses Python identifier type
    __type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'type'), 'type', '__httpwww_opengis_netgml3_2_OperationParameterGroupPropertyType_httpwww_w3_org1999xlinktype', _ImportedBinding_bindings_v1411_write__xlink.typeType, fixed=True, unicode_default='simple')
    __type._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 29, 1)
    __type._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 112, 2)
    
    type = property(__type.value, __type.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}href uses Python identifier href
    __href = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'href'), 'href', '__httpwww_opengis_netgml3_2_OperationParameterGroupPropertyType_httpwww_w3_org1999xlinkhref', _ImportedBinding_bindings_v1411_write__xlink.hrefType)
    __href._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 42, 1)
    __href._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 113, 2)
    
    href = property(__href.value, __href.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}role uses Python identifier role
    __role = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'role'), 'role', '__httpwww_opengis_netgml3_2_OperationParameterGroupPropertyType_httpwww_w3_org1999xlinkrole', _ImportedBinding_bindings_v1411_write__xlink.roleType)
    __role._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 48, 1)
    __role._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 114, 2)
    
    role = property(__role.value, __role.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}arcrole uses Python identifier arcrole
    __arcrole = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'arcrole'), 'arcrole', '__httpwww_opengis_netgml3_2_OperationParameterGroupPropertyType_httpwww_w3_org1999xlinkarcrole', _ImportedBinding_bindings_v1411_write__xlink.arcroleType)
    __arcrole._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 56, 1)
    __arcrole._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 115, 2)
    
    arcrole = property(__arcrole.value, __arcrole.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}title uses Python identifier title
    __title = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'title'), 'title', '__httpwww_opengis_netgml3_2_OperationParameterGroupPropertyType_httpwww_w3_org1999xlinktitle', _ImportedBinding_bindings_v1411_write__xlink.titleAttrType)
    __title._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 64, 1)
    __title._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 116, 2)
    
    title = property(__title.value, __title.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}show uses Python identifier show
    __show = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'show'), 'show', '__httpwww_opengis_netgml3_2_OperationParameterGroupPropertyType_httpwww_w3_org1999xlinkshow', _ImportedBinding_bindings_v1411_write__xlink.showType)
    __show._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 70, 1)
    __show._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 117, 2)
    
    show = property(__show.value, __show.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}actuate uses Python identifier actuate
    __actuate = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'actuate'), 'actuate', '__httpwww_opengis_netgml3_2_OperationParameterGroupPropertyType_httpwww_w3_org1999xlinkactuate', _ImportedBinding_bindings_v1411_write__xlink.actuateType)
    __actuate._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 82, 1)
    __actuate._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 118, 2)
    
    actuate = property(__actuate.value, __actuate.set, None, None)

    _ElementMap.update({
        __OperationParameterGroup.name() : __OperationParameterGroup
    })
    _AttributeMap.update({
        __remoteSchema.name() : __remoteSchema,
        __nilReason.name() : __nilReason,
        __type.name() : __type,
        __href.name() : __href,
        __role.name() : __role,
        __arcrole.name() : __arcrole,
        __title.name() : __title,
        __show.name() : __show,
        __actuate.name() : __actuate
    })
_module_typeBindings.OperationParameterGroupPropertyType = OperationParameterGroupPropertyType
_Namespace_gml.addCategoryObject('typeBinding', 'OperationParameterGroupPropertyType', OperationParameterGroupPropertyType)


# Complex type {http://www.opengis.net/gml/3.2}SingleCRSPropertyType with content type ELEMENT_ONLY
class SingleCRSPropertyType (pyxb.binding.basis.complexTypeDefinition):
    """gml:SingleCRSPropertyType is a property type for association roles to a single coordinate reference system, either referencing or containing the definition of that coordinate reference system."""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'SingleCRSPropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateReferenceSystems.xsd', 23, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.opengis.net/gml/3.2}AbstractSingleCRS uses Python identifier AbstractSingleCRS
    __AbstractSingleCRS = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractSingleCRS'), 'AbstractSingleCRS', '__httpwww_opengis_netgml3_2_SingleCRSPropertyType_httpwww_opengis_netgml3_2AbstractSingleCRS', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateReferenceSystems.xsd', 18, 1), )

    
    AbstractSingleCRS = property(__AbstractSingleCRS.value, __AbstractSingleCRS.set, None, 'gml:AbstractSingleCRS implements a coordinate reference system consisting of one coordinate system and one datum (as opposed to a Compound CRS).')

    
    # Attribute {http://www.opengis.net/gml/3.2}remoteSchema uses Python identifier remoteSchema
    __remoteSchema = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gml, 'remoteSchema'), 'remoteSchema', '__httpwww_opengis_netgml3_2_SingleCRSPropertyType_httpwww_opengis_netgml3_2remoteSchema', pyxb.binding.datatypes.anyURI)
    __remoteSchema._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 638, 1)
    __remoteSchema._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 52, 2)
    
    remoteSchema = property(__remoteSchema.value, __remoteSchema.set, None, '')

    
    # Attribute nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'nilReason'), 'nilReason', '__httpwww_opengis_netgml3_2_SingleCRSPropertyType_nilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 51, 2)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 51, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}type uses Python identifier type
    __type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'type'), 'type', '__httpwww_opengis_netgml3_2_SingleCRSPropertyType_httpwww_w3_org1999xlinktype', _ImportedBinding_bindings_v1411_write__xlink.typeType, fixed=True, unicode_default='simple')
    __type._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 29, 1)
    __type._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 112, 2)
    
    type = property(__type.value, __type.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}href uses Python identifier href
    __href = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'href'), 'href', '__httpwww_opengis_netgml3_2_SingleCRSPropertyType_httpwww_w3_org1999xlinkhref', _ImportedBinding_bindings_v1411_write__xlink.hrefType)
    __href._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 42, 1)
    __href._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 113, 2)
    
    href = property(__href.value, __href.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}role uses Python identifier role
    __role = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'role'), 'role', '__httpwww_opengis_netgml3_2_SingleCRSPropertyType_httpwww_w3_org1999xlinkrole', _ImportedBinding_bindings_v1411_write__xlink.roleType)
    __role._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 48, 1)
    __role._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 114, 2)
    
    role = property(__role.value, __role.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}arcrole uses Python identifier arcrole
    __arcrole = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'arcrole'), 'arcrole', '__httpwww_opengis_netgml3_2_SingleCRSPropertyType_httpwww_w3_org1999xlinkarcrole', _ImportedBinding_bindings_v1411_write__xlink.arcroleType)
    __arcrole._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 56, 1)
    __arcrole._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 115, 2)
    
    arcrole = property(__arcrole.value, __arcrole.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}title uses Python identifier title
    __title = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'title'), 'title', '__httpwww_opengis_netgml3_2_SingleCRSPropertyType_httpwww_w3_org1999xlinktitle', _ImportedBinding_bindings_v1411_write__xlink.titleAttrType)
    __title._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 64, 1)
    __title._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 116, 2)
    
    title = property(__title.value, __title.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}show uses Python identifier show
    __show = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'show'), 'show', '__httpwww_opengis_netgml3_2_SingleCRSPropertyType_httpwww_w3_org1999xlinkshow', _ImportedBinding_bindings_v1411_write__xlink.showType)
    __show._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 70, 1)
    __show._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 117, 2)
    
    show = property(__show.value, __show.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}actuate uses Python identifier actuate
    __actuate = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'actuate'), 'actuate', '__httpwww_opengis_netgml3_2_SingleCRSPropertyType_httpwww_w3_org1999xlinkactuate', _ImportedBinding_bindings_v1411_write__xlink.actuateType)
    __actuate._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 82, 1)
    __actuate._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 118, 2)
    
    actuate = property(__actuate.value, __actuate.set, None, None)

    _ElementMap.update({
        __AbstractSingleCRS.name() : __AbstractSingleCRS
    })
    _AttributeMap.update({
        __remoteSchema.name() : __remoteSchema,
        __nilReason.name() : __nilReason,
        __type.name() : __type,
        __href.name() : __href,
        __role.name() : __role,
        __arcrole.name() : __arcrole,
        __title.name() : __title,
        __show.name() : __show,
        __actuate.name() : __actuate
    })
_module_typeBindings.SingleCRSPropertyType = SingleCRSPropertyType
_Namespace_gml.addCategoryObject('typeBinding', 'SingleCRSPropertyType', SingleCRSPropertyType)


# Complex type {http://www.opengis.net/gml/3.2}CompoundCRSPropertyType with content type ELEMENT_ONLY
class CompoundCRSPropertyType (pyxb.binding.basis.complexTypeDefinition):
    """gml:CompoundCRSPropertyType is a property type for association roles to a compound coordinate reference system, either referencing or containing the definition of that reference system."""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'CompoundCRSPropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateReferenceSystems.xsd', 71, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.opengis.net/gml/3.2}CompoundCRS uses Python identifier CompoundCRS
    __CompoundCRS = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'CompoundCRS'), 'CompoundCRS', '__httpwww_opengis_netgml3_2_CompoundCRSPropertyType_httpwww_opengis_netgml3_2CompoundCRS', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateReferenceSystems.xsd', 51, 1), )

    
    CompoundCRS = property(__CompoundCRS.value, __CompoundCRS.set, None, 'gml:CompundCRS is a coordinate reference system describing the position of points through two or more independent coordinate reference systems. It is associated with a non-repeating sequence of two or more instances of SingleCRS.')

    
    # Attribute {http://www.opengis.net/gml/3.2}remoteSchema uses Python identifier remoteSchema
    __remoteSchema = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gml, 'remoteSchema'), 'remoteSchema', '__httpwww_opengis_netgml3_2_CompoundCRSPropertyType_httpwww_opengis_netgml3_2remoteSchema', pyxb.binding.datatypes.anyURI)
    __remoteSchema._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 638, 1)
    __remoteSchema._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 52, 2)
    
    remoteSchema = property(__remoteSchema.value, __remoteSchema.set, None, '')

    
    # Attribute nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'nilReason'), 'nilReason', '__httpwww_opengis_netgml3_2_CompoundCRSPropertyType_nilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 51, 2)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 51, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}type uses Python identifier type
    __type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'type'), 'type', '__httpwww_opengis_netgml3_2_CompoundCRSPropertyType_httpwww_w3_org1999xlinktype', _ImportedBinding_bindings_v1411_write__xlink.typeType, fixed=True, unicode_default='simple')
    __type._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 29, 1)
    __type._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 112, 2)
    
    type = property(__type.value, __type.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}href uses Python identifier href
    __href = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'href'), 'href', '__httpwww_opengis_netgml3_2_CompoundCRSPropertyType_httpwww_w3_org1999xlinkhref', _ImportedBinding_bindings_v1411_write__xlink.hrefType)
    __href._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 42, 1)
    __href._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 113, 2)
    
    href = property(__href.value, __href.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}role uses Python identifier role
    __role = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'role'), 'role', '__httpwww_opengis_netgml3_2_CompoundCRSPropertyType_httpwww_w3_org1999xlinkrole', _ImportedBinding_bindings_v1411_write__xlink.roleType)
    __role._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 48, 1)
    __role._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 114, 2)
    
    role = property(__role.value, __role.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}arcrole uses Python identifier arcrole
    __arcrole = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'arcrole'), 'arcrole', '__httpwww_opengis_netgml3_2_CompoundCRSPropertyType_httpwww_w3_org1999xlinkarcrole', _ImportedBinding_bindings_v1411_write__xlink.arcroleType)
    __arcrole._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 56, 1)
    __arcrole._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 115, 2)
    
    arcrole = property(__arcrole.value, __arcrole.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}title uses Python identifier title
    __title = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'title'), 'title', '__httpwww_opengis_netgml3_2_CompoundCRSPropertyType_httpwww_w3_org1999xlinktitle', _ImportedBinding_bindings_v1411_write__xlink.titleAttrType)
    __title._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 64, 1)
    __title._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 116, 2)
    
    title = property(__title.value, __title.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}show uses Python identifier show
    __show = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'show'), 'show', '__httpwww_opengis_netgml3_2_CompoundCRSPropertyType_httpwww_w3_org1999xlinkshow', _ImportedBinding_bindings_v1411_write__xlink.showType)
    __show._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 70, 1)
    __show._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 117, 2)
    
    show = property(__show.value, __show.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}actuate uses Python identifier actuate
    __actuate = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'actuate'), 'actuate', '__httpwww_opengis_netgml3_2_CompoundCRSPropertyType_httpwww_w3_org1999xlinkactuate', _ImportedBinding_bindings_v1411_write__xlink.actuateType)
    __actuate._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 82, 1)
    __actuate._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 118, 2)
    
    actuate = property(__actuate.value, __actuate.set, None, None)

    _ElementMap.update({
        __CompoundCRS.name() : __CompoundCRS
    })
    _AttributeMap.update({
        __remoteSchema.name() : __remoteSchema,
        __nilReason.name() : __nilReason,
        __type.name() : __type,
        __href.name() : __href,
        __role.name() : __role,
        __arcrole.name() : __arcrole,
        __title.name() : __title,
        __show.name() : __show,
        __actuate.name() : __actuate
    })
_module_typeBindings.CompoundCRSPropertyType = CompoundCRSPropertyType
_Namespace_gml.addCategoryObject('typeBinding', 'CompoundCRSPropertyType', CompoundCRSPropertyType)


# Complex type {http://www.opengis.net/gml/3.2}GeodeticCRSPropertyType with content type ELEMENT_ONLY
class GeodeticCRSPropertyType (pyxb.binding.basis.complexTypeDefinition):
    """gml:GeodeticCRSPropertyType is a property type for association roles to a geodetic coordinate reference system, either referencing or containing the definition of that reference system."""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'GeodeticCRSPropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateReferenceSystems.xsd', 119, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.opengis.net/gml/3.2}GeodeticCRS uses Python identifier GeodeticCRS
    __GeodeticCRS = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'GeodeticCRS'), 'GeodeticCRS', '__httpwww_opengis_netgml3_2_GeodeticCRSPropertyType_httpwww_opengis_netgml3_2GeodeticCRS', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateReferenceSystems.xsd', 80, 1), )

    
    GeodeticCRS = property(__GeodeticCRS.value, __GeodeticCRS.set, None, None)

    
    # Attribute {http://www.opengis.net/gml/3.2}remoteSchema uses Python identifier remoteSchema
    __remoteSchema = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gml, 'remoteSchema'), 'remoteSchema', '__httpwww_opengis_netgml3_2_GeodeticCRSPropertyType_httpwww_opengis_netgml3_2remoteSchema', pyxb.binding.datatypes.anyURI)
    __remoteSchema._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 638, 1)
    __remoteSchema._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 52, 2)
    
    remoteSchema = property(__remoteSchema.value, __remoteSchema.set, None, '')

    
    # Attribute nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'nilReason'), 'nilReason', '__httpwww_opengis_netgml3_2_GeodeticCRSPropertyType_nilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 51, 2)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 51, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}type uses Python identifier type
    __type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'type'), 'type', '__httpwww_opengis_netgml3_2_GeodeticCRSPropertyType_httpwww_w3_org1999xlinktype', _ImportedBinding_bindings_v1411_write__xlink.typeType, fixed=True, unicode_default='simple')
    __type._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 29, 1)
    __type._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 112, 2)
    
    type = property(__type.value, __type.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}href uses Python identifier href
    __href = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'href'), 'href', '__httpwww_opengis_netgml3_2_GeodeticCRSPropertyType_httpwww_w3_org1999xlinkhref', _ImportedBinding_bindings_v1411_write__xlink.hrefType)
    __href._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 42, 1)
    __href._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 113, 2)
    
    href = property(__href.value, __href.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}role uses Python identifier role
    __role = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'role'), 'role', '__httpwww_opengis_netgml3_2_GeodeticCRSPropertyType_httpwww_w3_org1999xlinkrole', _ImportedBinding_bindings_v1411_write__xlink.roleType)
    __role._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 48, 1)
    __role._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 114, 2)
    
    role = property(__role.value, __role.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}arcrole uses Python identifier arcrole
    __arcrole = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'arcrole'), 'arcrole', '__httpwww_opengis_netgml3_2_GeodeticCRSPropertyType_httpwww_w3_org1999xlinkarcrole', _ImportedBinding_bindings_v1411_write__xlink.arcroleType)
    __arcrole._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 56, 1)
    __arcrole._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 115, 2)
    
    arcrole = property(__arcrole.value, __arcrole.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}title uses Python identifier title
    __title = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'title'), 'title', '__httpwww_opengis_netgml3_2_GeodeticCRSPropertyType_httpwww_w3_org1999xlinktitle', _ImportedBinding_bindings_v1411_write__xlink.titleAttrType)
    __title._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 64, 1)
    __title._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 116, 2)
    
    title = property(__title.value, __title.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}show uses Python identifier show
    __show = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'show'), 'show', '__httpwww_opengis_netgml3_2_GeodeticCRSPropertyType_httpwww_w3_org1999xlinkshow', _ImportedBinding_bindings_v1411_write__xlink.showType)
    __show._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 70, 1)
    __show._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 117, 2)
    
    show = property(__show.value, __show.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}actuate uses Python identifier actuate
    __actuate = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'actuate'), 'actuate', '__httpwww_opengis_netgml3_2_GeodeticCRSPropertyType_httpwww_w3_org1999xlinkactuate', _ImportedBinding_bindings_v1411_write__xlink.actuateType)
    __actuate._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 82, 1)
    __actuate._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 118, 2)
    
    actuate = property(__actuate.value, __actuate.set, None, None)

    _ElementMap.update({
        __GeodeticCRS.name() : __GeodeticCRS
    })
    _AttributeMap.update({
        __remoteSchema.name() : __remoteSchema,
        __nilReason.name() : __nilReason,
        __type.name() : __type,
        __href.name() : __href,
        __role.name() : __role,
        __arcrole.name() : __arcrole,
        __title.name() : __title,
        __show.name() : __show,
        __actuate.name() : __actuate
    })
_module_typeBindings.GeodeticCRSPropertyType = GeodeticCRSPropertyType
_Namespace_gml.addCategoryObject('typeBinding', 'GeodeticCRSPropertyType', GeodeticCRSPropertyType)


# Complex type {http://www.opengis.net/gml/3.2}VerticalCRSPropertyType with content type ELEMENT_ONLY
class VerticalCRSPropertyType (pyxb.binding.basis.complexTypeDefinition):
    """gml:VerticalCRSPropertyType is a property type for association roles to a vertical coordinate reference system, either referencing or containing the definition of that reference system."""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'VerticalCRSPropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateReferenceSystems.xsd', 153, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.opengis.net/gml/3.2}VerticalCRS uses Python identifier VerticalCRS
    __VerticalCRS = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'VerticalCRS'), 'VerticalCRS', '__httpwww_opengis_netgml3_2_VerticalCRSPropertyType_httpwww_opengis_netgml3_2VerticalCRS', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateReferenceSystems.xsd', 128, 1), )

    
    VerticalCRS = property(__VerticalCRS.value, __VerticalCRS.set, None, 'gml:VerticalCRS is a 1D coordinate reference system used for recording heights or depths. Vertical CRSs make use of the direction of gravity to define the concept of height or depth, but the relationship with gravity may not be straightforward. By implication, ellipsoidal heights (h) cannot be captured in a vertical coordinate reference system. Ellipsoidal heights cannot exist independently, but only as an inseparable part of a 3D coordinate tuple defined in a geographic 3D coordinate reference system.')

    
    # Attribute {http://www.opengis.net/gml/3.2}remoteSchema uses Python identifier remoteSchema
    __remoteSchema = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gml, 'remoteSchema'), 'remoteSchema', '__httpwww_opengis_netgml3_2_VerticalCRSPropertyType_httpwww_opengis_netgml3_2remoteSchema', pyxb.binding.datatypes.anyURI)
    __remoteSchema._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 638, 1)
    __remoteSchema._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 52, 2)
    
    remoteSchema = property(__remoteSchema.value, __remoteSchema.set, None, '')

    
    # Attribute nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'nilReason'), 'nilReason', '__httpwww_opengis_netgml3_2_VerticalCRSPropertyType_nilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 51, 2)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 51, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}type uses Python identifier type
    __type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'type'), 'type', '__httpwww_opengis_netgml3_2_VerticalCRSPropertyType_httpwww_w3_org1999xlinktype', _ImportedBinding_bindings_v1411_write__xlink.typeType, fixed=True, unicode_default='simple')
    __type._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 29, 1)
    __type._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 112, 2)
    
    type = property(__type.value, __type.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}href uses Python identifier href
    __href = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'href'), 'href', '__httpwww_opengis_netgml3_2_VerticalCRSPropertyType_httpwww_w3_org1999xlinkhref', _ImportedBinding_bindings_v1411_write__xlink.hrefType)
    __href._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 42, 1)
    __href._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 113, 2)
    
    href = property(__href.value, __href.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}role uses Python identifier role
    __role = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'role'), 'role', '__httpwww_opengis_netgml3_2_VerticalCRSPropertyType_httpwww_w3_org1999xlinkrole', _ImportedBinding_bindings_v1411_write__xlink.roleType)
    __role._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 48, 1)
    __role._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 114, 2)
    
    role = property(__role.value, __role.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}arcrole uses Python identifier arcrole
    __arcrole = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'arcrole'), 'arcrole', '__httpwww_opengis_netgml3_2_VerticalCRSPropertyType_httpwww_w3_org1999xlinkarcrole', _ImportedBinding_bindings_v1411_write__xlink.arcroleType)
    __arcrole._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 56, 1)
    __arcrole._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 115, 2)
    
    arcrole = property(__arcrole.value, __arcrole.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}title uses Python identifier title
    __title = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'title'), 'title', '__httpwww_opengis_netgml3_2_VerticalCRSPropertyType_httpwww_w3_org1999xlinktitle', _ImportedBinding_bindings_v1411_write__xlink.titleAttrType)
    __title._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 64, 1)
    __title._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 116, 2)
    
    title = property(__title.value, __title.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}show uses Python identifier show
    __show = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'show'), 'show', '__httpwww_opengis_netgml3_2_VerticalCRSPropertyType_httpwww_w3_org1999xlinkshow', _ImportedBinding_bindings_v1411_write__xlink.showType)
    __show._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 70, 1)
    __show._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 117, 2)
    
    show = property(__show.value, __show.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}actuate uses Python identifier actuate
    __actuate = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'actuate'), 'actuate', '__httpwww_opengis_netgml3_2_VerticalCRSPropertyType_httpwww_w3_org1999xlinkactuate', _ImportedBinding_bindings_v1411_write__xlink.actuateType)
    __actuate._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 82, 1)
    __actuate._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 118, 2)
    
    actuate = property(__actuate.value, __actuate.set, None, None)

    _ElementMap.update({
        __VerticalCRS.name() : __VerticalCRS
    })
    _AttributeMap.update({
        __remoteSchema.name() : __remoteSchema,
        __nilReason.name() : __nilReason,
        __type.name() : __type,
        __href.name() : __href,
        __role.name() : __role,
        __arcrole.name() : __arcrole,
        __title.name() : __title,
        __show.name() : __show,
        __actuate.name() : __actuate
    })
_module_typeBindings.VerticalCRSPropertyType = VerticalCRSPropertyType
_Namespace_gml.addCategoryObject('typeBinding', 'VerticalCRSPropertyType', VerticalCRSPropertyType)


# Complex type {http://www.opengis.net/gml/3.2}ProjectedCRSPropertyType with content type ELEMENT_ONLY
class ProjectedCRSPropertyType (pyxb.binding.basis.complexTypeDefinition):
    """gml:ProjectedCRSPropertyType is a property type for association roles to a projected coordinate reference system, either referencing or containing the definition of that reference system."""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'ProjectedCRSPropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateReferenceSystems.xsd', 185, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.opengis.net/gml/3.2}ProjectedCRS uses Python identifier ProjectedCRS
    __ProjectedCRS = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'ProjectedCRS'), 'ProjectedCRS', '__httpwww_opengis_netgml3_2_ProjectedCRSPropertyType_httpwww_opengis_netgml3_2ProjectedCRS', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateReferenceSystems.xsd', 162, 1), )

    
    ProjectedCRS = property(__ProjectedCRS.value, __ProjectedCRS.set, None, 'gml:ProjectedCRS is a 2D coordinate reference system used to approximate the shape of the earth on a planar surface, but in such a way that the distortion that is inherent to the approximation is carefully controlled and known. Distortion correction is commonly applied to calculated bearings and distances to produce values that are a close match to actual field values.')

    
    # Attribute {http://www.opengis.net/gml/3.2}remoteSchema uses Python identifier remoteSchema
    __remoteSchema = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gml, 'remoteSchema'), 'remoteSchema', '__httpwww_opengis_netgml3_2_ProjectedCRSPropertyType_httpwww_opengis_netgml3_2remoteSchema', pyxb.binding.datatypes.anyURI)
    __remoteSchema._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 638, 1)
    __remoteSchema._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 52, 2)
    
    remoteSchema = property(__remoteSchema.value, __remoteSchema.set, None, '')

    
    # Attribute nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'nilReason'), 'nilReason', '__httpwww_opengis_netgml3_2_ProjectedCRSPropertyType_nilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 51, 2)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 51, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}type uses Python identifier type
    __type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'type'), 'type', '__httpwww_opengis_netgml3_2_ProjectedCRSPropertyType_httpwww_w3_org1999xlinktype', _ImportedBinding_bindings_v1411_write__xlink.typeType, fixed=True, unicode_default='simple')
    __type._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 29, 1)
    __type._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 112, 2)
    
    type = property(__type.value, __type.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}href uses Python identifier href
    __href = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'href'), 'href', '__httpwww_opengis_netgml3_2_ProjectedCRSPropertyType_httpwww_w3_org1999xlinkhref', _ImportedBinding_bindings_v1411_write__xlink.hrefType)
    __href._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 42, 1)
    __href._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 113, 2)
    
    href = property(__href.value, __href.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}role uses Python identifier role
    __role = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'role'), 'role', '__httpwww_opengis_netgml3_2_ProjectedCRSPropertyType_httpwww_w3_org1999xlinkrole', _ImportedBinding_bindings_v1411_write__xlink.roleType)
    __role._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 48, 1)
    __role._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 114, 2)
    
    role = property(__role.value, __role.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}arcrole uses Python identifier arcrole
    __arcrole = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'arcrole'), 'arcrole', '__httpwww_opengis_netgml3_2_ProjectedCRSPropertyType_httpwww_w3_org1999xlinkarcrole', _ImportedBinding_bindings_v1411_write__xlink.arcroleType)
    __arcrole._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 56, 1)
    __arcrole._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 115, 2)
    
    arcrole = property(__arcrole.value, __arcrole.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}title uses Python identifier title
    __title = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'title'), 'title', '__httpwww_opengis_netgml3_2_ProjectedCRSPropertyType_httpwww_w3_org1999xlinktitle', _ImportedBinding_bindings_v1411_write__xlink.titleAttrType)
    __title._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 64, 1)
    __title._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 116, 2)
    
    title = property(__title.value, __title.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}show uses Python identifier show
    __show = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'show'), 'show', '__httpwww_opengis_netgml3_2_ProjectedCRSPropertyType_httpwww_w3_org1999xlinkshow', _ImportedBinding_bindings_v1411_write__xlink.showType)
    __show._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 70, 1)
    __show._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 117, 2)
    
    show = property(__show.value, __show.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}actuate uses Python identifier actuate
    __actuate = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'actuate'), 'actuate', '__httpwww_opengis_netgml3_2_ProjectedCRSPropertyType_httpwww_w3_org1999xlinkactuate', _ImportedBinding_bindings_v1411_write__xlink.actuateType)
    __actuate._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 82, 1)
    __actuate._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 118, 2)
    
    actuate = property(__actuate.value, __actuate.set, None, None)

    _ElementMap.update({
        __ProjectedCRS.name() : __ProjectedCRS
    })
    _AttributeMap.update({
        __remoteSchema.name() : __remoteSchema,
        __nilReason.name() : __nilReason,
        __type.name() : __type,
        __href.name() : __href,
        __role.name() : __role,
        __arcrole.name() : __arcrole,
        __title.name() : __title,
        __show.name() : __show,
        __actuate.name() : __actuate
    })
_module_typeBindings.ProjectedCRSPropertyType = ProjectedCRSPropertyType
_Namespace_gml.addCategoryObject('typeBinding', 'ProjectedCRSPropertyType', ProjectedCRSPropertyType)


# Complex type {http://www.opengis.net/gml/3.2}DerivedCRSPropertyType with content type ELEMENT_ONLY
class DerivedCRSPropertyType (pyxb.binding.basis.complexTypeDefinition):
    """gml:DerivedCRSPropertyType is a property type for association roles to a non-projected derived coordinate reference system, either referencing or containing the definition of that reference system."""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'DerivedCRSPropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateReferenceSystems.xsd', 225, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.opengis.net/gml/3.2}DerivedCRS uses Python identifier DerivedCRS
    __DerivedCRS = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'DerivedCRS'), 'DerivedCRS', '__httpwww_opengis_netgml3_2_DerivedCRSPropertyType_httpwww_opengis_netgml3_2DerivedCRS', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateReferenceSystems.xsd', 194, 1), )

    
    DerivedCRS = property(__DerivedCRS.value, __DerivedCRS.set, None, 'gml:DerivedCRS is a single coordinate reference system that is defined by its coordinate conversion from another single coordinate reference system known as the base CRS. The base CRS can be a projected coordinate reference system, if this DerivedCRS is used for a georectified grid coverage as described in ISO 19123, Clause 8.')

    
    # Attribute {http://www.opengis.net/gml/3.2}remoteSchema uses Python identifier remoteSchema
    __remoteSchema = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gml, 'remoteSchema'), 'remoteSchema', '__httpwww_opengis_netgml3_2_DerivedCRSPropertyType_httpwww_opengis_netgml3_2remoteSchema', pyxb.binding.datatypes.anyURI)
    __remoteSchema._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 638, 1)
    __remoteSchema._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 52, 2)
    
    remoteSchema = property(__remoteSchema.value, __remoteSchema.set, None, '')

    
    # Attribute nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'nilReason'), 'nilReason', '__httpwww_opengis_netgml3_2_DerivedCRSPropertyType_nilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 51, 2)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 51, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}type uses Python identifier type
    __type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'type'), 'type', '__httpwww_opengis_netgml3_2_DerivedCRSPropertyType_httpwww_w3_org1999xlinktype', _ImportedBinding_bindings_v1411_write__xlink.typeType, fixed=True, unicode_default='simple')
    __type._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 29, 1)
    __type._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 112, 2)
    
    type = property(__type.value, __type.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}href uses Python identifier href
    __href = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'href'), 'href', '__httpwww_opengis_netgml3_2_DerivedCRSPropertyType_httpwww_w3_org1999xlinkhref', _ImportedBinding_bindings_v1411_write__xlink.hrefType)
    __href._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 42, 1)
    __href._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 113, 2)
    
    href = property(__href.value, __href.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}role uses Python identifier role
    __role = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'role'), 'role', '__httpwww_opengis_netgml3_2_DerivedCRSPropertyType_httpwww_w3_org1999xlinkrole', _ImportedBinding_bindings_v1411_write__xlink.roleType)
    __role._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 48, 1)
    __role._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 114, 2)
    
    role = property(__role.value, __role.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}arcrole uses Python identifier arcrole
    __arcrole = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'arcrole'), 'arcrole', '__httpwww_opengis_netgml3_2_DerivedCRSPropertyType_httpwww_w3_org1999xlinkarcrole', _ImportedBinding_bindings_v1411_write__xlink.arcroleType)
    __arcrole._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 56, 1)
    __arcrole._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 115, 2)
    
    arcrole = property(__arcrole.value, __arcrole.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}title uses Python identifier title
    __title = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'title'), 'title', '__httpwww_opengis_netgml3_2_DerivedCRSPropertyType_httpwww_w3_org1999xlinktitle', _ImportedBinding_bindings_v1411_write__xlink.titleAttrType)
    __title._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 64, 1)
    __title._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 116, 2)
    
    title = property(__title.value, __title.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}show uses Python identifier show
    __show = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'show'), 'show', '__httpwww_opengis_netgml3_2_DerivedCRSPropertyType_httpwww_w3_org1999xlinkshow', _ImportedBinding_bindings_v1411_write__xlink.showType)
    __show._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 70, 1)
    __show._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 117, 2)
    
    show = property(__show.value, __show.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}actuate uses Python identifier actuate
    __actuate = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'actuate'), 'actuate', '__httpwww_opengis_netgml3_2_DerivedCRSPropertyType_httpwww_w3_org1999xlinkactuate', _ImportedBinding_bindings_v1411_write__xlink.actuateType)
    __actuate._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 82, 1)
    __actuate._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 118, 2)
    
    actuate = property(__actuate.value, __actuate.set, None, None)

    _ElementMap.update({
        __DerivedCRS.name() : __DerivedCRS
    })
    _AttributeMap.update({
        __remoteSchema.name() : __remoteSchema,
        __nilReason.name() : __nilReason,
        __type.name() : __type,
        __href.name() : __href,
        __role.name() : __role,
        __arcrole.name() : __arcrole,
        __title.name() : __title,
        __show.name() : __show,
        __actuate.name() : __actuate
    })
_module_typeBindings.DerivedCRSPropertyType = DerivedCRSPropertyType
_Namespace_gml.addCategoryObject('typeBinding', 'DerivedCRSPropertyType', DerivedCRSPropertyType)


# Complex type {http://www.opengis.net/gml/3.2}EngineeringCRSPropertyType with content type ELEMENT_ONLY
class EngineeringCRSPropertyType (pyxb.binding.basis.complexTypeDefinition):
    """gml:EngineeringCRSPropertyType is a property type for association roles to an engineering coordinate reference system, either referencing or containing the definition of that reference system."""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'EngineeringCRSPropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateReferenceSystems.xsd', 289, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.opengis.net/gml/3.2}EngineeringCRS uses Python identifier EngineeringCRS
    __EngineeringCRS = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'EngineeringCRS'), 'EngineeringCRS', '__httpwww_opengis_netgml3_2_EngineeringCRSPropertyType_httpwww_opengis_netgml3_2EngineeringCRS', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateReferenceSystems.xsd', 234, 1), )

    
    EngineeringCRS = property(__EngineeringCRS.value, __EngineeringCRS.set, None, 'gml:EngineeringCRS is a contextually local coordinate reference system which can be divided into two broad categories:\n-\tearth-fixed systems applied to engineering activities on or near the surface of the earth;\n-\tCRSs on moving platforms such as road vehicles, vessels, aircraft, or spacecraft, see ISO 19111 8.3.')

    
    # Attribute {http://www.opengis.net/gml/3.2}remoteSchema uses Python identifier remoteSchema
    __remoteSchema = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gml, 'remoteSchema'), 'remoteSchema', '__httpwww_opengis_netgml3_2_EngineeringCRSPropertyType_httpwww_opengis_netgml3_2remoteSchema', pyxb.binding.datatypes.anyURI)
    __remoteSchema._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 638, 1)
    __remoteSchema._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 52, 2)
    
    remoteSchema = property(__remoteSchema.value, __remoteSchema.set, None, '')

    
    # Attribute nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'nilReason'), 'nilReason', '__httpwww_opengis_netgml3_2_EngineeringCRSPropertyType_nilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 51, 2)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 51, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}type uses Python identifier type
    __type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'type'), 'type', '__httpwww_opengis_netgml3_2_EngineeringCRSPropertyType_httpwww_w3_org1999xlinktype', _ImportedBinding_bindings_v1411_write__xlink.typeType, fixed=True, unicode_default='simple')
    __type._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 29, 1)
    __type._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 112, 2)
    
    type = property(__type.value, __type.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}href uses Python identifier href
    __href = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'href'), 'href', '__httpwww_opengis_netgml3_2_EngineeringCRSPropertyType_httpwww_w3_org1999xlinkhref', _ImportedBinding_bindings_v1411_write__xlink.hrefType)
    __href._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 42, 1)
    __href._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 113, 2)
    
    href = property(__href.value, __href.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}role uses Python identifier role
    __role = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'role'), 'role', '__httpwww_opengis_netgml3_2_EngineeringCRSPropertyType_httpwww_w3_org1999xlinkrole', _ImportedBinding_bindings_v1411_write__xlink.roleType)
    __role._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 48, 1)
    __role._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 114, 2)
    
    role = property(__role.value, __role.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}arcrole uses Python identifier arcrole
    __arcrole = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'arcrole'), 'arcrole', '__httpwww_opengis_netgml3_2_EngineeringCRSPropertyType_httpwww_w3_org1999xlinkarcrole', _ImportedBinding_bindings_v1411_write__xlink.arcroleType)
    __arcrole._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 56, 1)
    __arcrole._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 115, 2)
    
    arcrole = property(__arcrole.value, __arcrole.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}title uses Python identifier title
    __title = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'title'), 'title', '__httpwww_opengis_netgml3_2_EngineeringCRSPropertyType_httpwww_w3_org1999xlinktitle', _ImportedBinding_bindings_v1411_write__xlink.titleAttrType)
    __title._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 64, 1)
    __title._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 116, 2)
    
    title = property(__title.value, __title.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}show uses Python identifier show
    __show = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'show'), 'show', '__httpwww_opengis_netgml3_2_EngineeringCRSPropertyType_httpwww_w3_org1999xlinkshow', _ImportedBinding_bindings_v1411_write__xlink.showType)
    __show._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 70, 1)
    __show._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 117, 2)
    
    show = property(__show.value, __show.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}actuate uses Python identifier actuate
    __actuate = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'actuate'), 'actuate', '__httpwww_opengis_netgml3_2_EngineeringCRSPropertyType_httpwww_w3_org1999xlinkactuate', _ImportedBinding_bindings_v1411_write__xlink.actuateType)
    __actuate._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 82, 1)
    __actuate._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 118, 2)
    
    actuate = property(__actuate.value, __actuate.set, None, None)

    _ElementMap.update({
        __EngineeringCRS.name() : __EngineeringCRS
    })
    _AttributeMap.update({
        __remoteSchema.name() : __remoteSchema,
        __nilReason.name() : __nilReason,
        __type.name() : __type,
        __href.name() : __href,
        __role.name() : __role,
        __arcrole.name() : __arcrole,
        __title.name() : __title,
        __show.name() : __show,
        __actuate.name() : __actuate
    })
_module_typeBindings.EngineeringCRSPropertyType = EngineeringCRSPropertyType
_Namespace_gml.addCategoryObject('typeBinding', 'EngineeringCRSPropertyType', EngineeringCRSPropertyType)


# Complex type {http://www.opengis.net/gml/3.2}ImageCRSPropertyType with content type ELEMENT_ONLY
class ImageCRSPropertyType (pyxb.binding.basis.complexTypeDefinition):
    """gml:ImageCRSPropertyType is a property type for association roles to an image coordinate reference system, either referencing or containing the definition of that reference system."""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'ImageCRSPropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateReferenceSystems.xsd', 327, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.opengis.net/gml/3.2}ImageCRS uses Python identifier ImageCRS
    __ImageCRS = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'ImageCRS'), 'ImageCRS', '__httpwww_opengis_netgml3_2_ImageCRSPropertyType_httpwww_opengis_netgml3_2ImageCRS', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateReferenceSystems.xsd', 298, 1), )

    
    ImageCRS = property(__ImageCRS.value, __ImageCRS.set, None, 'gml:ImageCRS is an engineering coordinate reference system applied to locations in images. Image coordinate reference systems are treated as a separate sub-type because the definition of the associated image datum contains two attributes not relevant to other engineering datums.')

    
    # Attribute {http://www.opengis.net/gml/3.2}remoteSchema uses Python identifier remoteSchema
    __remoteSchema = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gml, 'remoteSchema'), 'remoteSchema', '__httpwww_opengis_netgml3_2_ImageCRSPropertyType_httpwww_opengis_netgml3_2remoteSchema', pyxb.binding.datatypes.anyURI)
    __remoteSchema._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 638, 1)
    __remoteSchema._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 52, 2)
    
    remoteSchema = property(__remoteSchema.value, __remoteSchema.set, None, '')

    
    # Attribute nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'nilReason'), 'nilReason', '__httpwww_opengis_netgml3_2_ImageCRSPropertyType_nilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 51, 2)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 51, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}type uses Python identifier type
    __type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'type'), 'type', '__httpwww_opengis_netgml3_2_ImageCRSPropertyType_httpwww_w3_org1999xlinktype', _ImportedBinding_bindings_v1411_write__xlink.typeType, fixed=True, unicode_default='simple')
    __type._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 29, 1)
    __type._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 112, 2)
    
    type = property(__type.value, __type.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}href uses Python identifier href
    __href = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'href'), 'href', '__httpwww_opengis_netgml3_2_ImageCRSPropertyType_httpwww_w3_org1999xlinkhref', _ImportedBinding_bindings_v1411_write__xlink.hrefType)
    __href._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 42, 1)
    __href._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 113, 2)
    
    href = property(__href.value, __href.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}role uses Python identifier role
    __role = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'role'), 'role', '__httpwww_opengis_netgml3_2_ImageCRSPropertyType_httpwww_w3_org1999xlinkrole', _ImportedBinding_bindings_v1411_write__xlink.roleType)
    __role._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 48, 1)
    __role._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 114, 2)
    
    role = property(__role.value, __role.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}arcrole uses Python identifier arcrole
    __arcrole = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'arcrole'), 'arcrole', '__httpwww_opengis_netgml3_2_ImageCRSPropertyType_httpwww_w3_org1999xlinkarcrole', _ImportedBinding_bindings_v1411_write__xlink.arcroleType)
    __arcrole._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 56, 1)
    __arcrole._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 115, 2)
    
    arcrole = property(__arcrole.value, __arcrole.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}title uses Python identifier title
    __title = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'title'), 'title', '__httpwww_opengis_netgml3_2_ImageCRSPropertyType_httpwww_w3_org1999xlinktitle', _ImportedBinding_bindings_v1411_write__xlink.titleAttrType)
    __title._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 64, 1)
    __title._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 116, 2)
    
    title = property(__title.value, __title.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}show uses Python identifier show
    __show = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'show'), 'show', '__httpwww_opengis_netgml3_2_ImageCRSPropertyType_httpwww_w3_org1999xlinkshow', _ImportedBinding_bindings_v1411_write__xlink.showType)
    __show._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 70, 1)
    __show._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 117, 2)
    
    show = property(__show.value, __show.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}actuate uses Python identifier actuate
    __actuate = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'actuate'), 'actuate', '__httpwww_opengis_netgml3_2_ImageCRSPropertyType_httpwww_w3_org1999xlinkactuate', _ImportedBinding_bindings_v1411_write__xlink.actuateType)
    __actuate._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 82, 1)
    __actuate._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 118, 2)
    
    actuate = property(__actuate.value, __actuate.set, None, None)

    _ElementMap.update({
        __ImageCRS.name() : __ImageCRS
    })
    _AttributeMap.update({
        __remoteSchema.name() : __remoteSchema,
        __nilReason.name() : __nilReason,
        __type.name() : __type,
        __href.name() : __href,
        __role.name() : __role,
        __arcrole.name() : __arcrole,
        __title.name() : __title,
        __show.name() : __show,
        __actuate.name() : __actuate
    })
_module_typeBindings.ImageCRSPropertyType = ImageCRSPropertyType
_Namespace_gml.addCategoryObject('typeBinding', 'ImageCRSPropertyType', ImageCRSPropertyType)


# Complex type {http://www.opengis.net/gml/3.2}TemporalCRSPropertyType with content type ELEMENT_ONLY
class TemporalCRSPropertyType (pyxb.binding.basis.complexTypeDefinition):
    """gml:TemporalCRSPropertyType is a property type for association roles to a temporal coordinate reference system, either referencing or containing the definition of that reference system."""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'TemporalCRSPropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateReferenceSystems.xsd', 364, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.opengis.net/gml/3.2}TemporalCRS uses Python identifier TemporalCRS
    __TemporalCRS = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'TemporalCRS'), 'TemporalCRS', '__httpwww_opengis_netgml3_2_TemporalCRSPropertyType_httpwww_opengis_netgml3_2TemporalCRS', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateReferenceSystems.xsd', 336, 1), )

    
    TemporalCRS = property(__TemporalCRS.value, __TemporalCRS.set, None, 'gml:TemporalCRS is a 1D coordinate reference system used for the recording of time.')

    
    # Attribute {http://www.opengis.net/gml/3.2}remoteSchema uses Python identifier remoteSchema
    __remoteSchema = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gml, 'remoteSchema'), 'remoteSchema', '__httpwww_opengis_netgml3_2_TemporalCRSPropertyType_httpwww_opengis_netgml3_2remoteSchema', pyxb.binding.datatypes.anyURI)
    __remoteSchema._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 638, 1)
    __remoteSchema._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 52, 2)
    
    remoteSchema = property(__remoteSchema.value, __remoteSchema.set, None, '')

    
    # Attribute nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'nilReason'), 'nilReason', '__httpwww_opengis_netgml3_2_TemporalCRSPropertyType_nilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 51, 2)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 51, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}type uses Python identifier type
    __type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'type'), 'type', '__httpwww_opengis_netgml3_2_TemporalCRSPropertyType_httpwww_w3_org1999xlinktype', _ImportedBinding_bindings_v1411_write__xlink.typeType, fixed=True, unicode_default='simple')
    __type._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 29, 1)
    __type._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 112, 2)
    
    type = property(__type.value, __type.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}href uses Python identifier href
    __href = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'href'), 'href', '__httpwww_opengis_netgml3_2_TemporalCRSPropertyType_httpwww_w3_org1999xlinkhref', _ImportedBinding_bindings_v1411_write__xlink.hrefType)
    __href._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 42, 1)
    __href._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 113, 2)
    
    href = property(__href.value, __href.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}role uses Python identifier role
    __role = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'role'), 'role', '__httpwww_opengis_netgml3_2_TemporalCRSPropertyType_httpwww_w3_org1999xlinkrole', _ImportedBinding_bindings_v1411_write__xlink.roleType)
    __role._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 48, 1)
    __role._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 114, 2)
    
    role = property(__role.value, __role.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}arcrole uses Python identifier arcrole
    __arcrole = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'arcrole'), 'arcrole', '__httpwww_opengis_netgml3_2_TemporalCRSPropertyType_httpwww_w3_org1999xlinkarcrole', _ImportedBinding_bindings_v1411_write__xlink.arcroleType)
    __arcrole._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 56, 1)
    __arcrole._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 115, 2)
    
    arcrole = property(__arcrole.value, __arcrole.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}title uses Python identifier title
    __title = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'title'), 'title', '__httpwww_opengis_netgml3_2_TemporalCRSPropertyType_httpwww_w3_org1999xlinktitle', _ImportedBinding_bindings_v1411_write__xlink.titleAttrType)
    __title._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 64, 1)
    __title._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 116, 2)
    
    title = property(__title.value, __title.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}show uses Python identifier show
    __show = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'show'), 'show', '__httpwww_opengis_netgml3_2_TemporalCRSPropertyType_httpwww_w3_org1999xlinkshow', _ImportedBinding_bindings_v1411_write__xlink.showType)
    __show._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 70, 1)
    __show._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 117, 2)
    
    show = property(__show.value, __show.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}actuate uses Python identifier actuate
    __actuate = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'actuate'), 'actuate', '__httpwww_opengis_netgml3_2_TemporalCRSPropertyType_httpwww_w3_org1999xlinkactuate', _ImportedBinding_bindings_v1411_write__xlink.actuateType)
    __actuate._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 82, 1)
    __actuate._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 118, 2)
    
    actuate = property(__actuate.value, __actuate.set, None, None)

    _ElementMap.update({
        __TemporalCRS.name() : __TemporalCRS
    })
    _AttributeMap.update({
        __remoteSchema.name() : __remoteSchema,
        __nilReason.name() : __nilReason,
        __type.name() : __type,
        __href.name() : __href,
        __role.name() : __role,
        __arcrole.name() : __arcrole,
        __title.name() : __title,
        __show.name() : __show,
        __actuate.name() : __actuate
    })
_module_typeBindings.TemporalCRSPropertyType = TemporalCRSPropertyType
_Namespace_gml.addCategoryObject('typeBinding', 'TemporalCRSPropertyType', TemporalCRSPropertyType)


# Complex type {http://www.opengis.net/gml/3.2}CoordinateSystemAxisPropertyType with content type ELEMENT_ONLY
class CoordinateSystemAxisPropertyType (pyxb.binding.basis.complexTypeDefinition):
    """gml:CoordinateSystemAxisPropertyType is a property type for association roles to a coordinate system axis, either referencing or containing the definition of that axis."""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'CoordinateSystemAxisPropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateSystems.xsd', 69, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.opengis.net/gml/3.2}CoordinateSystemAxis uses Python identifier CoordinateSystemAxis
    __CoordinateSystemAxis = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'CoordinateSystemAxis'), 'CoordinateSystemAxis', '__httpwww_opengis_netgml3_2_CoordinateSystemAxisPropertyType_httpwww_opengis_netgml3_2CoordinateSystemAxis', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateSystems.xsd', 19, 1), )

    
    CoordinateSystemAxis = property(__CoordinateSystemAxis.value, __CoordinateSystemAxis.set, None, 'gml:CoordinateSystemAxis is a definition of a coordinate system axis.')

    
    # Attribute {http://www.opengis.net/gml/3.2}remoteSchema uses Python identifier remoteSchema
    __remoteSchema = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gml, 'remoteSchema'), 'remoteSchema', '__httpwww_opengis_netgml3_2_CoordinateSystemAxisPropertyType_httpwww_opengis_netgml3_2remoteSchema', pyxb.binding.datatypes.anyURI)
    __remoteSchema._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 638, 1)
    __remoteSchema._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 52, 2)
    
    remoteSchema = property(__remoteSchema.value, __remoteSchema.set, None, '')

    
    # Attribute nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'nilReason'), 'nilReason', '__httpwww_opengis_netgml3_2_CoordinateSystemAxisPropertyType_nilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 51, 2)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 51, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}type uses Python identifier type
    __type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'type'), 'type', '__httpwww_opengis_netgml3_2_CoordinateSystemAxisPropertyType_httpwww_w3_org1999xlinktype', _ImportedBinding_bindings_v1411_write__xlink.typeType, fixed=True, unicode_default='simple')
    __type._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 29, 1)
    __type._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 112, 2)
    
    type = property(__type.value, __type.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}href uses Python identifier href
    __href = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'href'), 'href', '__httpwww_opengis_netgml3_2_CoordinateSystemAxisPropertyType_httpwww_w3_org1999xlinkhref', _ImportedBinding_bindings_v1411_write__xlink.hrefType)
    __href._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 42, 1)
    __href._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 113, 2)
    
    href = property(__href.value, __href.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}role uses Python identifier role
    __role = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'role'), 'role', '__httpwww_opengis_netgml3_2_CoordinateSystemAxisPropertyType_httpwww_w3_org1999xlinkrole', _ImportedBinding_bindings_v1411_write__xlink.roleType)
    __role._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 48, 1)
    __role._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 114, 2)
    
    role = property(__role.value, __role.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}arcrole uses Python identifier arcrole
    __arcrole = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'arcrole'), 'arcrole', '__httpwww_opengis_netgml3_2_CoordinateSystemAxisPropertyType_httpwww_w3_org1999xlinkarcrole', _ImportedBinding_bindings_v1411_write__xlink.arcroleType)
    __arcrole._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 56, 1)
    __arcrole._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 115, 2)
    
    arcrole = property(__arcrole.value, __arcrole.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}title uses Python identifier title
    __title = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'title'), 'title', '__httpwww_opengis_netgml3_2_CoordinateSystemAxisPropertyType_httpwww_w3_org1999xlinktitle', _ImportedBinding_bindings_v1411_write__xlink.titleAttrType)
    __title._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 64, 1)
    __title._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 116, 2)
    
    title = property(__title.value, __title.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}show uses Python identifier show
    __show = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'show'), 'show', '__httpwww_opengis_netgml3_2_CoordinateSystemAxisPropertyType_httpwww_w3_org1999xlinkshow', _ImportedBinding_bindings_v1411_write__xlink.showType)
    __show._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 70, 1)
    __show._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 117, 2)
    
    show = property(__show.value, __show.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}actuate uses Python identifier actuate
    __actuate = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'actuate'), 'actuate', '__httpwww_opengis_netgml3_2_CoordinateSystemAxisPropertyType_httpwww_w3_org1999xlinkactuate', _ImportedBinding_bindings_v1411_write__xlink.actuateType)
    __actuate._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 82, 1)
    __actuate._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 118, 2)
    
    actuate = property(__actuate.value, __actuate.set, None, None)

    _ElementMap.update({
        __CoordinateSystemAxis.name() : __CoordinateSystemAxis
    })
    _AttributeMap.update({
        __remoteSchema.name() : __remoteSchema,
        __nilReason.name() : __nilReason,
        __type.name() : __type,
        __href.name() : __href,
        __role.name() : __role,
        __arcrole.name() : __arcrole,
        __title.name() : __title,
        __show.name() : __show,
        __actuate.name() : __actuate
    })
_module_typeBindings.CoordinateSystemAxisPropertyType = CoordinateSystemAxisPropertyType
_Namespace_gml.addCategoryObject('typeBinding', 'CoordinateSystemAxisPropertyType', CoordinateSystemAxisPropertyType)


# Complex type {http://www.opengis.net/gml/3.2}CoordinateSystemPropertyType with content type ELEMENT_ONLY
class CoordinateSystemPropertyType (pyxb.binding.basis.complexTypeDefinition):
    """gml:CoordinateSystemPropertyType is a property type for association roles to a coordinate system, either referencing or containing the definition of that coordinate system."""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'CoordinateSystemPropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateSystems.xsd', 98, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.opengis.net/gml/3.2}AbstractCoordinateSystem uses Python identifier AbstractCoordinateSystem
    __AbstractCoordinateSystem = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractCoordinateSystem'), 'AbstractCoordinateSystem', '__httpwww_opengis_netgml3_2_CoordinateSystemPropertyType_httpwww_opengis_netgml3_2AbstractCoordinateSystem', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateSystems.xsd', 78, 1), )

    
    AbstractCoordinateSystem = property(__AbstractCoordinateSystem.value, __AbstractCoordinateSystem.set, None, 'gml:AbstractCoordinateSystem is a coordinate system (CS) is the non-repeating sequence of coordinate system axes that spans a given coordinate space. A CS is derived from a set of mathematical rules for specifying how coordinates in a given space are to be assigned to points. The coordinate values in a coordinate tuple shall be recorded in the order in which the coordinate system axes associations are recorded. This abstract complex type shall not be used, extended, or restricted, in an Application Schema, to define a concrete subtype with a meaning equivalent to a concrete subtype specified in this document.')

    
    # Attribute {http://www.opengis.net/gml/3.2}remoteSchema uses Python identifier remoteSchema
    __remoteSchema = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gml, 'remoteSchema'), 'remoteSchema', '__httpwww_opengis_netgml3_2_CoordinateSystemPropertyType_httpwww_opengis_netgml3_2remoteSchema', pyxb.binding.datatypes.anyURI)
    __remoteSchema._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 638, 1)
    __remoteSchema._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 52, 2)
    
    remoteSchema = property(__remoteSchema.value, __remoteSchema.set, None, '')

    
    # Attribute nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'nilReason'), 'nilReason', '__httpwww_opengis_netgml3_2_CoordinateSystemPropertyType_nilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 51, 2)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 51, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}type uses Python identifier type
    __type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'type'), 'type', '__httpwww_opengis_netgml3_2_CoordinateSystemPropertyType_httpwww_w3_org1999xlinktype', _ImportedBinding_bindings_v1411_write__xlink.typeType, fixed=True, unicode_default='simple')
    __type._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 29, 1)
    __type._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 112, 2)
    
    type = property(__type.value, __type.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}href uses Python identifier href
    __href = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'href'), 'href', '__httpwww_opengis_netgml3_2_CoordinateSystemPropertyType_httpwww_w3_org1999xlinkhref', _ImportedBinding_bindings_v1411_write__xlink.hrefType)
    __href._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 42, 1)
    __href._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 113, 2)
    
    href = property(__href.value, __href.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}role uses Python identifier role
    __role = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'role'), 'role', '__httpwww_opengis_netgml3_2_CoordinateSystemPropertyType_httpwww_w3_org1999xlinkrole', _ImportedBinding_bindings_v1411_write__xlink.roleType)
    __role._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 48, 1)
    __role._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 114, 2)
    
    role = property(__role.value, __role.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}arcrole uses Python identifier arcrole
    __arcrole = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'arcrole'), 'arcrole', '__httpwww_opengis_netgml3_2_CoordinateSystemPropertyType_httpwww_w3_org1999xlinkarcrole', _ImportedBinding_bindings_v1411_write__xlink.arcroleType)
    __arcrole._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 56, 1)
    __arcrole._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 115, 2)
    
    arcrole = property(__arcrole.value, __arcrole.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}title uses Python identifier title
    __title = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'title'), 'title', '__httpwww_opengis_netgml3_2_CoordinateSystemPropertyType_httpwww_w3_org1999xlinktitle', _ImportedBinding_bindings_v1411_write__xlink.titleAttrType)
    __title._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 64, 1)
    __title._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 116, 2)
    
    title = property(__title.value, __title.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}show uses Python identifier show
    __show = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'show'), 'show', '__httpwww_opengis_netgml3_2_CoordinateSystemPropertyType_httpwww_w3_org1999xlinkshow', _ImportedBinding_bindings_v1411_write__xlink.showType)
    __show._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 70, 1)
    __show._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 117, 2)
    
    show = property(__show.value, __show.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}actuate uses Python identifier actuate
    __actuate = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'actuate'), 'actuate', '__httpwww_opengis_netgml3_2_CoordinateSystemPropertyType_httpwww_w3_org1999xlinkactuate', _ImportedBinding_bindings_v1411_write__xlink.actuateType)
    __actuate._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 82, 1)
    __actuate._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 118, 2)
    
    actuate = property(__actuate.value, __actuate.set, None, None)

    _ElementMap.update({
        __AbstractCoordinateSystem.name() : __AbstractCoordinateSystem
    })
    _AttributeMap.update({
        __remoteSchema.name() : __remoteSchema,
        __nilReason.name() : __nilReason,
        __type.name() : __type,
        __href.name() : __href,
        __role.name() : __role,
        __arcrole.name() : __arcrole,
        __title.name() : __title,
        __show.name() : __show,
        __actuate.name() : __actuate
    })
_module_typeBindings.CoordinateSystemPropertyType = CoordinateSystemPropertyType
_Namespace_gml.addCategoryObject('typeBinding', 'CoordinateSystemPropertyType', CoordinateSystemPropertyType)


# Complex type {http://www.opengis.net/gml/3.2}EllipsoidalCSPropertyType with content type ELEMENT_ONLY
class EllipsoidalCSPropertyType (pyxb.binding.basis.complexTypeDefinition):
    """gml:EllipsoidalCSPropertyType is a property type for association roles to an ellipsoidal coordinate system, either referencing or containing the definition of that coordinate system."""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'EllipsoidalCSPropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateSystems.xsd', 117, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.opengis.net/gml/3.2}EllipsoidalCS uses Python identifier EllipsoidalCS
    __EllipsoidalCS = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'EllipsoidalCS'), 'EllipsoidalCS', '__httpwww_opengis_netgml3_2_EllipsoidalCSPropertyType_httpwww_opengis_netgml3_2EllipsoidalCS', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateSystems.xsd', 107, 1), )

    
    EllipsoidalCS = property(__EllipsoidalCS.value, __EllipsoidalCS.set, None, 'gml:EllipsoidalCS is a two- or three-dimensional coordinate system in which position is specified by geodetic latitude, geodetic longitude, and (in the three-dimensional case) ellipsoidal height. An EllipsoidalCS shall have two or three gml:axis property elements; the number of associations shall equal the dimension of the CS.')

    
    # Attribute {http://www.opengis.net/gml/3.2}remoteSchema uses Python identifier remoteSchema
    __remoteSchema = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gml, 'remoteSchema'), 'remoteSchema', '__httpwww_opengis_netgml3_2_EllipsoidalCSPropertyType_httpwww_opengis_netgml3_2remoteSchema', pyxb.binding.datatypes.anyURI)
    __remoteSchema._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 638, 1)
    __remoteSchema._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 52, 2)
    
    remoteSchema = property(__remoteSchema.value, __remoteSchema.set, None, '')

    
    # Attribute nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'nilReason'), 'nilReason', '__httpwww_opengis_netgml3_2_EllipsoidalCSPropertyType_nilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 51, 2)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 51, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}type uses Python identifier type
    __type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'type'), 'type', '__httpwww_opengis_netgml3_2_EllipsoidalCSPropertyType_httpwww_w3_org1999xlinktype', _ImportedBinding_bindings_v1411_write__xlink.typeType, fixed=True, unicode_default='simple')
    __type._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 29, 1)
    __type._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 112, 2)
    
    type = property(__type.value, __type.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}href uses Python identifier href
    __href = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'href'), 'href', '__httpwww_opengis_netgml3_2_EllipsoidalCSPropertyType_httpwww_w3_org1999xlinkhref', _ImportedBinding_bindings_v1411_write__xlink.hrefType)
    __href._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 42, 1)
    __href._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 113, 2)
    
    href = property(__href.value, __href.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}role uses Python identifier role
    __role = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'role'), 'role', '__httpwww_opengis_netgml3_2_EllipsoidalCSPropertyType_httpwww_w3_org1999xlinkrole', _ImportedBinding_bindings_v1411_write__xlink.roleType)
    __role._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 48, 1)
    __role._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 114, 2)
    
    role = property(__role.value, __role.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}arcrole uses Python identifier arcrole
    __arcrole = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'arcrole'), 'arcrole', '__httpwww_opengis_netgml3_2_EllipsoidalCSPropertyType_httpwww_w3_org1999xlinkarcrole', _ImportedBinding_bindings_v1411_write__xlink.arcroleType)
    __arcrole._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 56, 1)
    __arcrole._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 115, 2)
    
    arcrole = property(__arcrole.value, __arcrole.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}title uses Python identifier title
    __title = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'title'), 'title', '__httpwww_opengis_netgml3_2_EllipsoidalCSPropertyType_httpwww_w3_org1999xlinktitle', _ImportedBinding_bindings_v1411_write__xlink.titleAttrType)
    __title._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 64, 1)
    __title._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 116, 2)
    
    title = property(__title.value, __title.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}show uses Python identifier show
    __show = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'show'), 'show', '__httpwww_opengis_netgml3_2_EllipsoidalCSPropertyType_httpwww_w3_org1999xlinkshow', _ImportedBinding_bindings_v1411_write__xlink.showType)
    __show._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 70, 1)
    __show._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 117, 2)
    
    show = property(__show.value, __show.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}actuate uses Python identifier actuate
    __actuate = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'actuate'), 'actuate', '__httpwww_opengis_netgml3_2_EllipsoidalCSPropertyType_httpwww_w3_org1999xlinkactuate', _ImportedBinding_bindings_v1411_write__xlink.actuateType)
    __actuate._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 82, 1)
    __actuate._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 118, 2)
    
    actuate = property(__actuate.value, __actuate.set, None, None)

    _ElementMap.update({
        __EllipsoidalCS.name() : __EllipsoidalCS
    })
    _AttributeMap.update({
        __remoteSchema.name() : __remoteSchema,
        __nilReason.name() : __nilReason,
        __type.name() : __type,
        __href.name() : __href,
        __role.name() : __role,
        __arcrole.name() : __arcrole,
        __title.name() : __title,
        __show.name() : __show,
        __actuate.name() : __actuate
    })
_module_typeBindings.EllipsoidalCSPropertyType = EllipsoidalCSPropertyType
_Namespace_gml.addCategoryObject('typeBinding', 'EllipsoidalCSPropertyType', EllipsoidalCSPropertyType)


# Complex type {http://www.opengis.net/gml/3.2}CartesianCSPropertyType with content type ELEMENT_ONLY
class CartesianCSPropertyType (pyxb.binding.basis.complexTypeDefinition):
    """gml:CartesianCSPropertyType is a property type for association roles to a Cartesian coordinate system, either referencing or containing the definition of that coordinate system."""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'CartesianCSPropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateSystems.xsd', 136, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.opengis.net/gml/3.2}CartesianCS uses Python identifier CartesianCS
    __CartesianCS = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'CartesianCS'), 'CartesianCS', '__httpwww_opengis_netgml3_2_CartesianCSPropertyType_httpwww_opengis_netgml3_2CartesianCS', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateSystems.xsd', 126, 1), )

    
    CartesianCS = property(__CartesianCS.value, __CartesianCS.set, None, 'gml:CartesianCS is a 1-, 2-, or 3-dimensional coordinate system. In the 1-dimensional case, it contains a single straight coordinate axis. In the 2- and 3-dimensional cases gives the position of points relative to orthogonal straight axes. In the multi-dimensional case, all axes shall have the same length unit of measure. A CartesianCS shall have one, two, or three gml:axis property elements.')

    
    # Attribute {http://www.opengis.net/gml/3.2}remoteSchema uses Python identifier remoteSchema
    __remoteSchema = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gml, 'remoteSchema'), 'remoteSchema', '__httpwww_opengis_netgml3_2_CartesianCSPropertyType_httpwww_opengis_netgml3_2remoteSchema', pyxb.binding.datatypes.anyURI)
    __remoteSchema._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 638, 1)
    __remoteSchema._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 52, 2)
    
    remoteSchema = property(__remoteSchema.value, __remoteSchema.set, None, '')

    
    # Attribute nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'nilReason'), 'nilReason', '__httpwww_opengis_netgml3_2_CartesianCSPropertyType_nilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 51, 2)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 51, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}type uses Python identifier type
    __type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'type'), 'type', '__httpwww_opengis_netgml3_2_CartesianCSPropertyType_httpwww_w3_org1999xlinktype', _ImportedBinding_bindings_v1411_write__xlink.typeType, fixed=True, unicode_default='simple')
    __type._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 29, 1)
    __type._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 112, 2)
    
    type = property(__type.value, __type.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}href uses Python identifier href
    __href = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'href'), 'href', '__httpwww_opengis_netgml3_2_CartesianCSPropertyType_httpwww_w3_org1999xlinkhref', _ImportedBinding_bindings_v1411_write__xlink.hrefType)
    __href._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 42, 1)
    __href._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 113, 2)
    
    href = property(__href.value, __href.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}role uses Python identifier role
    __role = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'role'), 'role', '__httpwww_opengis_netgml3_2_CartesianCSPropertyType_httpwww_w3_org1999xlinkrole', _ImportedBinding_bindings_v1411_write__xlink.roleType)
    __role._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 48, 1)
    __role._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 114, 2)
    
    role = property(__role.value, __role.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}arcrole uses Python identifier arcrole
    __arcrole = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'arcrole'), 'arcrole', '__httpwww_opengis_netgml3_2_CartesianCSPropertyType_httpwww_w3_org1999xlinkarcrole', _ImportedBinding_bindings_v1411_write__xlink.arcroleType)
    __arcrole._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 56, 1)
    __arcrole._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 115, 2)
    
    arcrole = property(__arcrole.value, __arcrole.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}title uses Python identifier title
    __title = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'title'), 'title', '__httpwww_opengis_netgml3_2_CartesianCSPropertyType_httpwww_w3_org1999xlinktitle', _ImportedBinding_bindings_v1411_write__xlink.titleAttrType)
    __title._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 64, 1)
    __title._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 116, 2)
    
    title = property(__title.value, __title.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}show uses Python identifier show
    __show = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'show'), 'show', '__httpwww_opengis_netgml3_2_CartesianCSPropertyType_httpwww_w3_org1999xlinkshow', _ImportedBinding_bindings_v1411_write__xlink.showType)
    __show._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 70, 1)
    __show._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 117, 2)
    
    show = property(__show.value, __show.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}actuate uses Python identifier actuate
    __actuate = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'actuate'), 'actuate', '__httpwww_opengis_netgml3_2_CartesianCSPropertyType_httpwww_w3_org1999xlinkactuate', _ImportedBinding_bindings_v1411_write__xlink.actuateType)
    __actuate._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 82, 1)
    __actuate._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 118, 2)
    
    actuate = property(__actuate.value, __actuate.set, None, None)

    _ElementMap.update({
        __CartesianCS.name() : __CartesianCS
    })
    _AttributeMap.update({
        __remoteSchema.name() : __remoteSchema,
        __nilReason.name() : __nilReason,
        __type.name() : __type,
        __href.name() : __href,
        __role.name() : __role,
        __arcrole.name() : __arcrole,
        __title.name() : __title,
        __show.name() : __show,
        __actuate.name() : __actuate
    })
_module_typeBindings.CartesianCSPropertyType = CartesianCSPropertyType
_Namespace_gml.addCategoryObject('typeBinding', 'CartesianCSPropertyType', CartesianCSPropertyType)


# Complex type {http://www.opengis.net/gml/3.2}VerticalCSPropertyType with content type ELEMENT_ONLY
class VerticalCSPropertyType (pyxb.binding.basis.complexTypeDefinition):
    """gml:VerticalCSPropertyType is a property type for association roles to a vertical coordinate system, either referencing or containing the definition of that coordinate system."""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'VerticalCSPropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateSystems.xsd', 155, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.opengis.net/gml/3.2}VerticalCS uses Python identifier VerticalCS
    __VerticalCS = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'VerticalCS'), 'VerticalCS', '__httpwww_opengis_netgml3_2_VerticalCSPropertyType_httpwww_opengis_netgml3_2VerticalCS', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateSystems.xsd', 145, 1), )

    
    VerticalCS = property(__VerticalCS.value, __VerticalCS.set, None, "gml:VerticalCS is a one-dimensional coordinate system used to record the heights or depths of points. Such a coordinate system is usually dependent on the Earth's gravity field, perhaps loosely as when atmospheric pressure is the basis for the vertical coordinate system axis. A VerticalCS shall have one gml:axis property element.")

    
    # Attribute {http://www.opengis.net/gml/3.2}remoteSchema uses Python identifier remoteSchema
    __remoteSchema = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gml, 'remoteSchema'), 'remoteSchema', '__httpwww_opengis_netgml3_2_VerticalCSPropertyType_httpwww_opengis_netgml3_2remoteSchema', pyxb.binding.datatypes.anyURI)
    __remoteSchema._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 638, 1)
    __remoteSchema._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 52, 2)
    
    remoteSchema = property(__remoteSchema.value, __remoteSchema.set, None, '')

    
    # Attribute nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'nilReason'), 'nilReason', '__httpwww_opengis_netgml3_2_VerticalCSPropertyType_nilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 51, 2)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 51, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}type uses Python identifier type
    __type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'type'), 'type', '__httpwww_opengis_netgml3_2_VerticalCSPropertyType_httpwww_w3_org1999xlinktype', _ImportedBinding_bindings_v1411_write__xlink.typeType, fixed=True, unicode_default='simple')
    __type._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 29, 1)
    __type._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 112, 2)
    
    type = property(__type.value, __type.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}href uses Python identifier href
    __href = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'href'), 'href', '__httpwww_opengis_netgml3_2_VerticalCSPropertyType_httpwww_w3_org1999xlinkhref', _ImportedBinding_bindings_v1411_write__xlink.hrefType)
    __href._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 42, 1)
    __href._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 113, 2)
    
    href = property(__href.value, __href.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}role uses Python identifier role
    __role = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'role'), 'role', '__httpwww_opengis_netgml3_2_VerticalCSPropertyType_httpwww_w3_org1999xlinkrole', _ImportedBinding_bindings_v1411_write__xlink.roleType)
    __role._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 48, 1)
    __role._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 114, 2)
    
    role = property(__role.value, __role.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}arcrole uses Python identifier arcrole
    __arcrole = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'arcrole'), 'arcrole', '__httpwww_opengis_netgml3_2_VerticalCSPropertyType_httpwww_w3_org1999xlinkarcrole', _ImportedBinding_bindings_v1411_write__xlink.arcroleType)
    __arcrole._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 56, 1)
    __arcrole._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 115, 2)
    
    arcrole = property(__arcrole.value, __arcrole.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}title uses Python identifier title
    __title = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'title'), 'title', '__httpwww_opengis_netgml3_2_VerticalCSPropertyType_httpwww_w3_org1999xlinktitle', _ImportedBinding_bindings_v1411_write__xlink.titleAttrType)
    __title._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 64, 1)
    __title._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 116, 2)
    
    title = property(__title.value, __title.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}show uses Python identifier show
    __show = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'show'), 'show', '__httpwww_opengis_netgml3_2_VerticalCSPropertyType_httpwww_w3_org1999xlinkshow', _ImportedBinding_bindings_v1411_write__xlink.showType)
    __show._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 70, 1)
    __show._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 117, 2)
    
    show = property(__show.value, __show.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}actuate uses Python identifier actuate
    __actuate = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'actuate'), 'actuate', '__httpwww_opengis_netgml3_2_VerticalCSPropertyType_httpwww_w3_org1999xlinkactuate', _ImportedBinding_bindings_v1411_write__xlink.actuateType)
    __actuate._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 82, 1)
    __actuate._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 118, 2)
    
    actuate = property(__actuate.value, __actuate.set, None, None)

    _ElementMap.update({
        __VerticalCS.name() : __VerticalCS
    })
    _AttributeMap.update({
        __remoteSchema.name() : __remoteSchema,
        __nilReason.name() : __nilReason,
        __type.name() : __type,
        __href.name() : __href,
        __role.name() : __role,
        __arcrole.name() : __arcrole,
        __title.name() : __title,
        __show.name() : __show,
        __actuate.name() : __actuate
    })
_module_typeBindings.VerticalCSPropertyType = VerticalCSPropertyType
_Namespace_gml.addCategoryObject('typeBinding', 'VerticalCSPropertyType', VerticalCSPropertyType)


# Complex type {http://www.opengis.net/gml/3.2}TimeCSPropertyType with content type ELEMENT_ONLY
class TimeCSPropertyType (pyxb.binding.basis.complexTypeDefinition):
    """gml:TimeCSPropertyType is a property type for association roles to a time coordinate system, either referencing or containing the definition of that coordinate system."""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'TimeCSPropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateSystems.xsd', 174, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.opengis.net/gml/3.2}TimeCS uses Python identifier TimeCS
    __TimeCS = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'TimeCS'), 'TimeCS', '__httpwww_opengis_netgml3_2_TimeCSPropertyType_httpwww_opengis_netgml3_2TimeCS', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateSystems.xsd', 164, 1), )

    
    TimeCS = property(__TimeCS.value, __TimeCS.set, None, 'gml:TimeCS is a one-dimensional coordinate system containing a time axis, used to describe the temporal position of a point in the specified time units from a specified time origin. A TimeCS shall have one gml:axis property element.')

    
    # Attribute {http://www.opengis.net/gml/3.2}remoteSchema uses Python identifier remoteSchema
    __remoteSchema = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gml, 'remoteSchema'), 'remoteSchema', '__httpwww_opengis_netgml3_2_TimeCSPropertyType_httpwww_opengis_netgml3_2remoteSchema', pyxb.binding.datatypes.anyURI)
    __remoteSchema._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 638, 1)
    __remoteSchema._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 52, 2)
    
    remoteSchema = property(__remoteSchema.value, __remoteSchema.set, None, '')

    
    # Attribute nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'nilReason'), 'nilReason', '__httpwww_opengis_netgml3_2_TimeCSPropertyType_nilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 51, 2)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 51, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}type uses Python identifier type
    __type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'type'), 'type', '__httpwww_opengis_netgml3_2_TimeCSPropertyType_httpwww_w3_org1999xlinktype', _ImportedBinding_bindings_v1411_write__xlink.typeType, fixed=True, unicode_default='simple')
    __type._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 29, 1)
    __type._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 112, 2)
    
    type = property(__type.value, __type.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}href uses Python identifier href
    __href = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'href'), 'href', '__httpwww_opengis_netgml3_2_TimeCSPropertyType_httpwww_w3_org1999xlinkhref', _ImportedBinding_bindings_v1411_write__xlink.hrefType)
    __href._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 42, 1)
    __href._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 113, 2)
    
    href = property(__href.value, __href.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}role uses Python identifier role
    __role = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'role'), 'role', '__httpwww_opengis_netgml3_2_TimeCSPropertyType_httpwww_w3_org1999xlinkrole', _ImportedBinding_bindings_v1411_write__xlink.roleType)
    __role._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 48, 1)
    __role._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 114, 2)
    
    role = property(__role.value, __role.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}arcrole uses Python identifier arcrole
    __arcrole = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'arcrole'), 'arcrole', '__httpwww_opengis_netgml3_2_TimeCSPropertyType_httpwww_w3_org1999xlinkarcrole', _ImportedBinding_bindings_v1411_write__xlink.arcroleType)
    __arcrole._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 56, 1)
    __arcrole._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 115, 2)
    
    arcrole = property(__arcrole.value, __arcrole.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}title uses Python identifier title
    __title = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'title'), 'title', '__httpwww_opengis_netgml3_2_TimeCSPropertyType_httpwww_w3_org1999xlinktitle', _ImportedBinding_bindings_v1411_write__xlink.titleAttrType)
    __title._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 64, 1)
    __title._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 116, 2)
    
    title = property(__title.value, __title.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}show uses Python identifier show
    __show = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'show'), 'show', '__httpwww_opengis_netgml3_2_TimeCSPropertyType_httpwww_w3_org1999xlinkshow', _ImportedBinding_bindings_v1411_write__xlink.showType)
    __show._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 70, 1)
    __show._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 117, 2)
    
    show = property(__show.value, __show.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}actuate uses Python identifier actuate
    __actuate = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'actuate'), 'actuate', '__httpwww_opengis_netgml3_2_TimeCSPropertyType_httpwww_w3_org1999xlinkactuate', _ImportedBinding_bindings_v1411_write__xlink.actuateType)
    __actuate._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 82, 1)
    __actuate._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 118, 2)
    
    actuate = property(__actuate.value, __actuate.set, None, None)

    _ElementMap.update({
        __TimeCS.name() : __TimeCS
    })
    _AttributeMap.update({
        __remoteSchema.name() : __remoteSchema,
        __nilReason.name() : __nilReason,
        __type.name() : __type,
        __href.name() : __href,
        __role.name() : __role,
        __arcrole.name() : __arcrole,
        __title.name() : __title,
        __show.name() : __show,
        __actuate.name() : __actuate
    })
_module_typeBindings.TimeCSPropertyType = TimeCSPropertyType
_Namespace_gml.addCategoryObject('typeBinding', 'TimeCSPropertyType', TimeCSPropertyType)


# Complex type {http://www.opengis.net/gml/3.2}LinearCSPropertyType with content type ELEMENT_ONLY
class LinearCSPropertyType (pyxb.binding.basis.complexTypeDefinition):
    """gml:LinearCSPropertyType is a property type for association roles to a linear coordinate system, either referencing or containing the definition of that coordinate system."""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'LinearCSPropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateSystems.xsd', 193, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.opengis.net/gml/3.2}LinearCS uses Python identifier LinearCS
    __LinearCS = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'LinearCS'), 'LinearCS', '__httpwww_opengis_netgml3_2_LinearCSPropertyType_httpwww_opengis_netgml3_2LinearCS', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateSystems.xsd', 183, 1), )

    
    LinearCS = property(__LinearCS.value, __LinearCS.set, None, 'gml:LinearCS is a one-dimensional coordinate system that consists of the points that lie on the single axis described. The associated coordinate is the distance – with or without offset – from the specified datum to the point along the axis. A LinearCS shall have one gml:axis property element.')

    
    # Attribute {http://www.opengis.net/gml/3.2}remoteSchema uses Python identifier remoteSchema
    __remoteSchema = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gml, 'remoteSchema'), 'remoteSchema', '__httpwww_opengis_netgml3_2_LinearCSPropertyType_httpwww_opengis_netgml3_2remoteSchema', pyxb.binding.datatypes.anyURI)
    __remoteSchema._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 638, 1)
    __remoteSchema._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 52, 2)
    
    remoteSchema = property(__remoteSchema.value, __remoteSchema.set, None, '')

    
    # Attribute nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'nilReason'), 'nilReason', '__httpwww_opengis_netgml3_2_LinearCSPropertyType_nilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 51, 2)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 51, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}type uses Python identifier type
    __type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'type'), 'type', '__httpwww_opengis_netgml3_2_LinearCSPropertyType_httpwww_w3_org1999xlinktype', _ImportedBinding_bindings_v1411_write__xlink.typeType, fixed=True, unicode_default='simple')
    __type._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 29, 1)
    __type._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 112, 2)
    
    type = property(__type.value, __type.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}href uses Python identifier href
    __href = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'href'), 'href', '__httpwww_opengis_netgml3_2_LinearCSPropertyType_httpwww_w3_org1999xlinkhref', _ImportedBinding_bindings_v1411_write__xlink.hrefType)
    __href._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 42, 1)
    __href._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 113, 2)
    
    href = property(__href.value, __href.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}role uses Python identifier role
    __role = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'role'), 'role', '__httpwww_opengis_netgml3_2_LinearCSPropertyType_httpwww_w3_org1999xlinkrole', _ImportedBinding_bindings_v1411_write__xlink.roleType)
    __role._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 48, 1)
    __role._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 114, 2)
    
    role = property(__role.value, __role.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}arcrole uses Python identifier arcrole
    __arcrole = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'arcrole'), 'arcrole', '__httpwww_opengis_netgml3_2_LinearCSPropertyType_httpwww_w3_org1999xlinkarcrole', _ImportedBinding_bindings_v1411_write__xlink.arcroleType)
    __arcrole._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 56, 1)
    __arcrole._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 115, 2)
    
    arcrole = property(__arcrole.value, __arcrole.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}title uses Python identifier title
    __title = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'title'), 'title', '__httpwww_opengis_netgml3_2_LinearCSPropertyType_httpwww_w3_org1999xlinktitle', _ImportedBinding_bindings_v1411_write__xlink.titleAttrType)
    __title._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 64, 1)
    __title._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 116, 2)
    
    title = property(__title.value, __title.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}show uses Python identifier show
    __show = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'show'), 'show', '__httpwww_opengis_netgml3_2_LinearCSPropertyType_httpwww_w3_org1999xlinkshow', _ImportedBinding_bindings_v1411_write__xlink.showType)
    __show._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 70, 1)
    __show._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 117, 2)
    
    show = property(__show.value, __show.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}actuate uses Python identifier actuate
    __actuate = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'actuate'), 'actuate', '__httpwww_opengis_netgml3_2_LinearCSPropertyType_httpwww_w3_org1999xlinkactuate', _ImportedBinding_bindings_v1411_write__xlink.actuateType)
    __actuate._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 82, 1)
    __actuate._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 118, 2)
    
    actuate = property(__actuate.value, __actuate.set, None, None)

    _ElementMap.update({
        __LinearCS.name() : __LinearCS
    })
    _AttributeMap.update({
        __remoteSchema.name() : __remoteSchema,
        __nilReason.name() : __nilReason,
        __type.name() : __type,
        __href.name() : __href,
        __role.name() : __role,
        __arcrole.name() : __arcrole,
        __title.name() : __title,
        __show.name() : __show,
        __actuate.name() : __actuate
    })
_module_typeBindings.LinearCSPropertyType = LinearCSPropertyType
_Namespace_gml.addCategoryObject('typeBinding', 'LinearCSPropertyType', LinearCSPropertyType)


# Complex type {http://www.opengis.net/gml/3.2}UserDefinedCSPropertyType with content type ELEMENT_ONLY
class UserDefinedCSPropertyType (pyxb.binding.basis.complexTypeDefinition):
    """gml:UserDefinedCSPropertyType is a property type for association roles to a user-defined coordinate system, either referencing or containing the definition of that coordinate system."""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'UserDefinedCSPropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateSystems.xsd', 212, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.opengis.net/gml/3.2}UserDefinedCS uses Python identifier UserDefinedCS
    __UserDefinedCS = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'UserDefinedCS'), 'UserDefinedCS', '__httpwww_opengis_netgml3_2_UserDefinedCSPropertyType_httpwww_opengis_netgml3_2UserDefinedCS', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateSystems.xsd', 202, 1), )

    
    UserDefinedCS = property(__UserDefinedCS.value, __UserDefinedCS.set, None, 'gml:UserDefinedCS is a two- or three-dimensional coordinate system that consists of any combination of coordinate axes not covered by any other coordinate system type. A UserDefinedCS shall have two or three gml:axis property elements; the number of property elements shall equal the dimension of the CS.')

    
    # Attribute {http://www.opengis.net/gml/3.2}remoteSchema uses Python identifier remoteSchema
    __remoteSchema = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gml, 'remoteSchema'), 'remoteSchema', '__httpwww_opengis_netgml3_2_UserDefinedCSPropertyType_httpwww_opengis_netgml3_2remoteSchema', pyxb.binding.datatypes.anyURI)
    __remoteSchema._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 638, 1)
    __remoteSchema._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 52, 2)
    
    remoteSchema = property(__remoteSchema.value, __remoteSchema.set, None, '')

    
    # Attribute nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'nilReason'), 'nilReason', '__httpwww_opengis_netgml3_2_UserDefinedCSPropertyType_nilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 51, 2)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 51, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}type uses Python identifier type
    __type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'type'), 'type', '__httpwww_opengis_netgml3_2_UserDefinedCSPropertyType_httpwww_w3_org1999xlinktype', _ImportedBinding_bindings_v1411_write__xlink.typeType, fixed=True, unicode_default='simple')
    __type._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 29, 1)
    __type._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 112, 2)
    
    type = property(__type.value, __type.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}href uses Python identifier href
    __href = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'href'), 'href', '__httpwww_opengis_netgml3_2_UserDefinedCSPropertyType_httpwww_w3_org1999xlinkhref', _ImportedBinding_bindings_v1411_write__xlink.hrefType)
    __href._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 42, 1)
    __href._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 113, 2)
    
    href = property(__href.value, __href.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}role uses Python identifier role
    __role = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'role'), 'role', '__httpwww_opengis_netgml3_2_UserDefinedCSPropertyType_httpwww_w3_org1999xlinkrole', _ImportedBinding_bindings_v1411_write__xlink.roleType)
    __role._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 48, 1)
    __role._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 114, 2)
    
    role = property(__role.value, __role.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}arcrole uses Python identifier arcrole
    __arcrole = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'arcrole'), 'arcrole', '__httpwww_opengis_netgml3_2_UserDefinedCSPropertyType_httpwww_w3_org1999xlinkarcrole', _ImportedBinding_bindings_v1411_write__xlink.arcroleType)
    __arcrole._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 56, 1)
    __arcrole._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 115, 2)
    
    arcrole = property(__arcrole.value, __arcrole.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}title uses Python identifier title
    __title = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'title'), 'title', '__httpwww_opengis_netgml3_2_UserDefinedCSPropertyType_httpwww_w3_org1999xlinktitle', _ImportedBinding_bindings_v1411_write__xlink.titleAttrType)
    __title._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 64, 1)
    __title._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 116, 2)
    
    title = property(__title.value, __title.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}show uses Python identifier show
    __show = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'show'), 'show', '__httpwww_opengis_netgml3_2_UserDefinedCSPropertyType_httpwww_w3_org1999xlinkshow', _ImportedBinding_bindings_v1411_write__xlink.showType)
    __show._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 70, 1)
    __show._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 117, 2)
    
    show = property(__show.value, __show.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}actuate uses Python identifier actuate
    __actuate = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'actuate'), 'actuate', '__httpwww_opengis_netgml3_2_UserDefinedCSPropertyType_httpwww_w3_org1999xlinkactuate', _ImportedBinding_bindings_v1411_write__xlink.actuateType)
    __actuate._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 82, 1)
    __actuate._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 118, 2)
    
    actuate = property(__actuate.value, __actuate.set, None, None)

    _ElementMap.update({
        __UserDefinedCS.name() : __UserDefinedCS
    })
    _AttributeMap.update({
        __remoteSchema.name() : __remoteSchema,
        __nilReason.name() : __nilReason,
        __type.name() : __type,
        __href.name() : __href,
        __role.name() : __role,
        __arcrole.name() : __arcrole,
        __title.name() : __title,
        __show.name() : __show,
        __actuate.name() : __actuate
    })
_module_typeBindings.UserDefinedCSPropertyType = UserDefinedCSPropertyType
_Namespace_gml.addCategoryObject('typeBinding', 'UserDefinedCSPropertyType', UserDefinedCSPropertyType)


# Complex type {http://www.opengis.net/gml/3.2}SphericalCSPropertyType with content type ELEMENT_ONLY
class SphericalCSPropertyType (pyxb.binding.basis.complexTypeDefinition):
    """gml:SphericalCSPropertyType is property type for association roles to a spherical coordinate system, either referencing or containing the definition of that coordinate system."""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'SphericalCSPropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateSystems.xsd', 231, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.opengis.net/gml/3.2}SphericalCS uses Python identifier SphericalCS
    __SphericalCS = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'SphericalCS'), 'SphericalCS', '__httpwww_opengis_netgml3_2_SphericalCSPropertyType_httpwww_opengis_netgml3_2SphericalCS', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateSystems.xsd', 221, 1), )

    
    SphericalCS = property(__SphericalCS.value, __SphericalCS.set, None, 'gml:SphericalCS is a three-dimensional coordinate system with one distance measured from the origin and two angular coordinates. A SphericalCS shall have three gml:axis property elements.')

    
    # Attribute {http://www.opengis.net/gml/3.2}remoteSchema uses Python identifier remoteSchema
    __remoteSchema = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gml, 'remoteSchema'), 'remoteSchema', '__httpwww_opengis_netgml3_2_SphericalCSPropertyType_httpwww_opengis_netgml3_2remoteSchema', pyxb.binding.datatypes.anyURI)
    __remoteSchema._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 638, 1)
    __remoteSchema._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 52, 2)
    
    remoteSchema = property(__remoteSchema.value, __remoteSchema.set, None, '')

    
    # Attribute nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'nilReason'), 'nilReason', '__httpwww_opengis_netgml3_2_SphericalCSPropertyType_nilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 51, 2)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 51, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}type uses Python identifier type
    __type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'type'), 'type', '__httpwww_opengis_netgml3_2_SphericalCSPropertyType_httpwww_w3_org1999xlinktype', _ImportedBinding_bindings_v1411_write__xlink.typeType, fixed=True, unicode_default='simple')
    __type._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 29, 1)
    __type._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 112, 2)
    
    type = property(__type.value, __type.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}href uses Python identifier href
    __href = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'href'), 'href', '__httpwww_opengis_netgml3_2_SphericalCSPropertyType_httpwww_w3_org1999xlinkhref', _ImportedBinding_bindings_v1411_write__xlink.hrefType)
    __href._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 42, 1)
    __href._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 113, 2)
    
    href = property(__href.value, __href.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}role uses Python identifier role
    __role = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'role'), 'role', '__httpwww_opengis_netgml3_2_SphericalCSPropertyType_httpwww_w3_org1999xlinkrole', _ImportedBinding_bindings_v1411_write__xlink.roleType)
    __role._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 48, 1)
    __role._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 114, 2)
    
    role = property(__role.value, __role.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}arcrole uses Python identifier arcrole
    __arcrole = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'arcrole'), 'arcrole', '__httpwww_opengis_netgml3_2_SphericalCSPropertyType_httpwww_w3_org1999xlinkarcrole', _ImportedBinding_bindings_v1411_write__xlink.arcroleType)
    __arcrole._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 56, 1)
    __arcrole._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 115, 2)
    
    arcrole = property(__arcrole.value, __arcrole.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}title uses Python identifier title
    __title = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'title'), 'title', '__httpwww_opengis_netgml3_2_SphericalCSPropertyType_httpwww_w3_org1999xlinktitle', _ImportedBinding_bindings_v1411_write__xlink.titleAttrType)
    __title._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 64, 1)
    __title._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 116, 2)
    
    title = property(__title.value, __title.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}show uses Python identifier show
    __show = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'show'), 'show', '__httpwww_opengis_netgml3_2_SphericalCSPropertyType_httpwww_w3_org1999xlinkshow', _ImportedBinding_bindings_v1411_write__xlink.showType)
    __show._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 70, 1)
    __show._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 117, 2)
    
    show = property(__show.value, __show.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}actuate uses Python identifier actuate
    __actuate = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'actuate'), 'actuate', '__httpwww_opengis_netgml3_2_SphericalCSPropertyType_httpwww_w3_org1999xlinkactuate', _ImportedBinding_bindings_v1411_write__xlink.actuateType)
    __actuate._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 82, 1)
    __actuate._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 118, 2)
    
    actuate = property(__actuate.value, __actuate.set, None, None)

    _ElementMap.update({
        __SphericalCS.name() : __SphericalCS
    })
    _AttributeMap.update({
        __remoteSchema.name() : __remoteSchema,
        __nilReason.name() : __nilReason,
        __type.name() : __type,
        __href.name() : __href,
        __role.name() : __role,
        __arcrole.name() : __arcrole,
        __title.name() : __title,
        __show.name() : __show,
        __actuate.name() : __actuate
    })
_module_typeBindings.SphericalCSPropertyType = SphericalCSPropertyType
_Namespace_gml.addCategoryObject('typeBinding', 'SphericalCSPropertyType', SphericalCSPropertyType)


# Complex type {http://www.opengis.net/gml/3.2}PolarCSPropertyType with content type ELEMENT_ONLY
class PolarCSPropertyType (pyxb.binding.basis.complexTypeDefinition):
    """gml:PolarCSPropertyType is a property type for association roles to a polar coordinate system, either referencing or containing the definition of that coordinate system."""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'PolarCSPropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateSystems.xsd', 250, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.opengis.net/gml/3.2}PolarCS uses Python identifier PolarCS
    __PolarCS = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'PolarCS'), 'PolarCS', '__httpwww_opengis_netgml3_2_PolarCSPropertyType_httpwww_opengis_netgml3_2PolarCS', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateSystems.xsd', 240, 1), )

    
    PolarCS = property(__PolarCS.value, __PolarCS.set, None, 'gml:PolarCS ia s two-dimensional coordinate system in which position is specified by the distance from the origin and the angle between the line from the origin to a point and a reference direction. A PolarCS shall have two gml:axis property elements.')

    
    # Attribute {http://www.opengis.net/gml/3.2}remoteSchema uses Python identifier remoteSchema
    __remoteSchema = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gml, 'remoteSchema'), 'remoteSchema', '__httpwww_opengis_netgml3_2_PolarCSPropertyType_httpwww_opengis_netgml3_2remoteSchema', pyxb.binding.datatypes.anyURI)
    __remoteSchema._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 638, 1)
    __remoteSchema._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 52, 2)
    
    remoteSchema = property(__remoteSchema.value, __remoteSchema.set, None, '')

    
    # Attribute nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'nilReason'), 'nilReason', '__httpwww_opengis_netgml3_2_PolarCSPropertyType_nilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 51, 2)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 51, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}type uses Python identifier type
    __type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'type'), 'type', '__httpwww_opengis_netgml3_2_PolarCSPropertyType_httpwww_w3_org1999xlinktype', _ImportedBinding_bindings_v1411_write__xlink.typeType, fixed=True, unicode_default='simple')
    __type._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 29, 1)
    __type._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 112, 2)
    
    type = property(__type.value, __type.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}href uses Python identifier href
    __href = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'href'), 'href', '__httpwww_opengis_netgml3_2_PolarCSPropertyType_httpwww_w3_org1999xlinkhref', _ImportedBinding_bindings_v1411_write__xlink.hrefType)
    __href._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 42, 1)
    __href._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 113, 2)
    
    href = property(__href.value, __href.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}role uses Python identifier role
    __role = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'role'), 'role', '__httpwww_opengis_netgml3_2_PolarCSPropertyType_httpwww_w3_org1999xlinkrole', _ImportedBinding_bindings_v1411_write__xlink.roleType)
    __role._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 48, 1)
    __role._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 114, 2)
    
    role = property(__role.value, __role.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}arcrole uses Python identifier arcrole
    __arcrole = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'arcrole'), 'arcrole', '__httpwww_opengis_netgml3_2_PolarCSPropertyType_httpwww_w3_org1999xlinkarcrole', _ImportedBinding_bindings_v1411_write__xlink.arcroleType)
    __arcrole._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 56, 1)
    __arcrole._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 115, 2)
    
    arcrole = property(__arcrole.value, __arcrole.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}title uses Python identifier title
    __title = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'title'), 'title', '__httpwww_opengis_netgml3_2_PolarCSPropertyType_httpwww_w3_org1999xlinktitle', _ImportedBinding_bindings_v1411_write__xlink.titleAttrType)
    __title._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 64, 1)
    __title._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 116, 2)
    
    title = property(__title.value, __title.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}show uses Python identifier show
    __show = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'show'), 'show', '__httpwww_opengis_netgml3_2_PolarCSPropertyType_httpwww_w3_org1999xlinkshow', _ImportedBinding_bindings_v1411_write__xlink.showType)
    __show._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 70, 1)
    __show._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 117, 2)
    
    show = property(__show.value, __show.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}actuate uses Python identifier actuate
    __actuate = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'actuate'), 'actuate', '__httpwww_opengis_netgml3_2_PolarCSPropertyType_httpwww_w3_org1999xlinkactuate', _ImportedBinding_bindings_v1411_write__xlink.actuateType)
    __actuate._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 82, 1)
    __actuate._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 118, 2)
    
    actuate = property(__actuate.value, __actuate.set, None, None)

    _ElementMap.update({
        __PolarCS.name() : __PolarCS
    })
    _AttributeMap.update({
        __remoteSchema.name() : __remoteSchema,
        __nilReason.name() : __nilReason,
        __type.name() : __type,
        __href.name() : __href,
        __role.name() : __role,
        __arcrole.name() : __arcrole,
        __title.name() : __title,
        __show.name() : __show,
        __actuate.name() : __actuate
    })
_module_typeBindings.PolarCSPropertyType = PolarCSPropertyType
_Namespace_gml.addCategoryObject('typeBinding', 'PolarCSPropertyType', PolarCSPropertyType)


# Complex type {http://www.opengis.net/gml/3.2}CylindricalCSPropertyType with content type ELEMENT_ONLY
class CylindricalCSPropertyType (pyxb.binding.basis.complexTypeDefinition):
    """gml:CylindricalCSPropertyType is a property type for association roles to a cylindrical coordinate system, either referencing or containing the definition of that coordinate system."""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'CylindricalCSPropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateSystems.xsd', 269, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.opengis.net/gml/3.2}CylindricalCS uses Python identifier CylindricalCS
    __CylindricalCS = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'CylindricalCS'), 'CylindricalCS', '__httpwww_opengis_netgml3_2_CylindricalCSPropertyType_httpwww_opengis_netgml3_2CylindricalCS', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateSystems.xsd', 259, 1), )

    
    CylindricalCS = property(__CylindricalCS.value, __CylindricalCS.set, None, 'gml:CylindricalCS is a three-dimensional coordinate system consisting of a polar coordinate system extended by a straight coordinate axis perpendicular to the plane spanned by the polar coordinate system. A CylindricalCS shall have three gml:axis property elements.')

    
    # Attribute {http://www.opengis.net/gml/3.2}remoteSchema uses Python identifier remoteSchema
    __remoteSchema = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gml, 'remoteSchema'), 'remoteSchema', '__httpwww_opengis_netgml3_2_CylindricalCSPropertyType_httpwww_opengis_netgml3_2remoteSchema', pyxb.binding.datatypes.anyURI)
    __remoteSchema._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 638, 1)
    __remoteSchema._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 52, 2)
    
    remoteSchema = property(__remoteSchema.value, __remoteSchema.set, None, '')

    
    # Attribute nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'nilReason'), 'nilReason', '__httpwww_opengis_netgml3_2_CylindricalCSPropertyType_nilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 51, 2)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 51, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}type uses Python identifier type
    __type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'type'), 'type', '__httpwww_opengis_netgml3_2_CylindricalCSPropertyType_httpwww_w3_org1999xlinktype', _ImportedBinding_bindings_v1411_write__xlink.typeType, fixed=True, unicode_default='simple')
    __type._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 29, 1)
    __type._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 112, 2)
    
    type = property(__type.value, __type.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}href uses Python identifier href
    __href = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'href'), 'href', '__httpwww_opengis_netgml3_2_CylindricalCSPropertyType_httpwww_w3_org1999xlinkhref', _ImportedBinding_bindings_v1411_write__xlink.hrefType)
    __href._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 42, 1)
    __href._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 113, 2)
    
    href = property(__href.value, __href.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}role uses Python identifier role
    __role = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'role'), 'role', '__httpwww_opengis_netgml3_2_CylindricalCSPropertyType_httpwww_w3_org1999xlinkrole', _ImportedBinding_bindings_v1411_write__xlink.roleType)
    __role._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 48, 1)
    __role._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 114, 2)
    
    role = property(__role.value, __role.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}arcrole uses Python identifier arcrole
    __arcrole = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'arcrole'), 'arcrole', '__httpwww_opengis_netgml3_2_CylindricalCSPropertyType_httpwww_w3_org1999xlinkarcrole', _ImportedBinding_bindings_v1411_write__xlink.arcroleType)
    __arcrole._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 56, 1)
    __arcrole._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 115, 2)
    
    arcrole = property(__arcrole.value, __arcrole.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}title uses Python identifier title
    __title = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'title'), 'title', '__httpwww_opengis_netgml3_2_CylindricalCSPropertyType_httpwww_w3_org1999xlinktitle', _ImportedBinding_bindings_v1411_write__xlink.titleAttrType)
    __title._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 64, 1)
    __title._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 116, 2)
    
    title = property(__title.value, __title.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}show uses Python identifier show
    __show = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'show'), 'show', '__httpwww_opengis_netgml3_2_CylindricalCSPropertyType_httpwww_w3_org1999xlinkshow', _ImportedBinding_bindings_v1411_write__xlink.showType)
    __show._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 70, 1)
    __show._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 117, 2)
    
    show = property(__show.value, __show.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}actuate uses Python identifier actuate
    __actuate = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'actuate'), 'actuate', '__httpwww_opengis_netgml3_2_CylindricalCSPropertyType_httpwww_w3_org1999xlinkactuate', _ImportedBinding_bindings_v1411_write__xlink.actuateType)
    __actuate._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 82, 1)
    __actuate._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 118, 2)
    
    actuate = property(__actuate.value, __actuate.set, None, None)

    _ElementMap.update({
        __CylindricalCS.name() : __CylindricalCS
    })
    _AttributeMap.update({
        __remoteSchema.name() : __remoteSchema,
        __nilReason.name() : __nilReason,
        __type.name() : __type,
        __href.name() : __href,
        __role.name() : __role,
        __arcrole.name() : __arcrole,
        __title.name() : __title,
        __show.name() : __show,
        __actuate.name() : __actuate
    })
_module_typeBindings.CylindricalCSPropertyType = CylindricalCSPropertyType
_Namespace_gml.addCategoryObject('typeBinding', 'CylindricalCSPropertyType', CylindricalCSPropertyType)


# Complex type {http://www.opengis.net/gml/3.2}AffineCSPropertyType with content type ELEMENT_ONLY
class AffineCSPropertyType (pyxb.binding.basis.complexTypeDefinition):
    """gml:AffineCSPropertyType is a property type for association roles to an affine coordinate system, either referencing or containing the definition of that coordinate system."""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'AffineCSPropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateSystems.xsd', 288, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.opengis.net/gml/3.2}AffineCS uses Python identifier AffineCS
    __AffineCS = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'AffineCS'), 'AffineCS', '__httpwww_opengis_netgml3_2_AffineCSPropertyType_httpwww_opengis_netgml3_2AffineCS', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateSystems.xsd', 278, 1), )

    
    AffineCS = property(__AffineCS.value, __AffineCS.set, None, 'gml:AffineCS is a two- or three-dimensional coordinate system with straight axes that are not necessarily orthogonal. An AffineCS shall have two or three gml:axis property elements; the number of property elements shall equal the dimension of the CS.')

    
    # Attribute {http://www.opengis.net/gml/3.2}remoteSchema uses Python identifier remoteSchema
    __remoteSchema = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gml, 'remoteSchema'), 'remoteSchema', '__httpwww_opengis_netgml3_2_AffineCSPropertyType_httpwww_opengis_netgml3_2remoteSchema', pyxb.binding.datatypes.anyURI)
    __remoteSchema._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 638, 1)
    __remoteSchema._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 52, 2)
    
    remoteSchema = property(__remoteSchema.value, __remoteSchema.set, None, '')

    
    # Attribute nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'nilReason'), 'nilReason', '__httpwww_opengis_netgml3_2_AffineCSPropertyType_nilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 51, 2)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 51, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}type uses Python identifier type
    __type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'type'), 'type', '__httpwww_opengis_netgml3_2_AffineCSPropertyType_httpwww_w3_org1999xlinktype', _ImportedBinding_bindings_v1411_write__xlink.typeType, fixed=True, unicode_default='simple')
    __type._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 29, 1)
    __type._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 112, 2)
    
    type = property(__type.value, __type.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}href uses Python identifier href
    __href = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'href'), 'href', '__httpwww_opengis_netgml3_2_AffineCSPropertyType_httpwww_w3_org1999xlinkhref', _ImportedBinding_bindings_v1411_write__xlink.hrefType)
    __href._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 42, 1)
    __href._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 113, 2)
    
    href = property(__href.value, __href.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}role uses Python identifier role
    __role = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'role'), 'role', '__httpwww_opengis_netgml3_2_AffineCSPropertyType_httpwww_w3_org1999xlinkrole', _ImportedBinding_bindings_v1411_write__xlink.roleType)
    __role._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 48, 1)
    __role._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 114, 2)
    
    role = property(__role.value, __role.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}arcrole uses Python identifier arcrole
    __arcrole = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'arcrole'), 'arcrole', '__httpwww_opengis_netgml3_2_AffineCSPropertyType_httpwww_w3_org1999xlinkarcrole', _ImportedBinding_bindings_v1411_write__xlink.arcroleType)
    __arcrole._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 56, 1)
    __arcrole._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 115, 2)
    
    arcrole = property(__arcrole.value, __arcrole.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}title uses Python identifier title
    __title = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'title'), 'title', '__httpwww_opengis_netgml3_2_AffineCSPropertyType_httpwww_w3_org1999xlinktitle', _ImportedBinding_bindings_v1411_write__xlink.titleAttrType)
    __title._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 64, 1)
    __title._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 116, 2)
    
    title = property(__title.value, __title.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}show uses Python identifier show
    __show = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'show'), 'show', '__httpwww_opengis_netgml3_2_AffineCSPropertyType_httpwww_w3_org1999xlinkshow', _ImportedBinding_bindings_v1411_write__xlink.showType)
    __show._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 70, 1)
    __show._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 117, 2)
    
    show = property(__show.value, __show.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}actuate uses Python identifier actuate
    __actuate = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'actuate'), 'actuate', '__httpwww_opengis_netgml3_2_AffineCSPropertyType_httpwww_w3_org1999xlinkactuate', _ImportedBinding_bindings_v1411_write__xlink.actuateType)
    __actuate._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 82, 1)
    __actuate._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 118, 2)
    
    actuate = property(__actuate.value, __actuate.set, None, None)

    _ElementMap.update({
        __AffineCS.name() : __AffineCS
    })
    _AttributeMap.update({
        __remoteSchema.name() : __remoteSchema,
        __nilReason.name() : __nilReason,
        __type.name() : __type,
        __href.name() : __href,
        __role.name() : __role,
        __arcrole.name() : __arcrole,
        __title.name() : __title,
        __show.name() : __show,
        __actuate.name() : __actuate
    })
_module_typeBindings.AffineCSPropertyType = AffineCSPropertyType
_Namespace_gml.addCategoryObject('typeBinding', 'AffineCSPropertyType', AffineCSPropertyType)


# Complex type {http://www.opengis.net/gml/3.2}AbstractCoverageType with content type ELEMENT_ONLY
class AbstractCoverageType (AbstractFeatureType):
    """The base type for coverages is gml:AbstractCoverageType. The basic elements of a coverage can be seen in this content model: the coverage contains gml:domainSet and gml:rangeSet properties. The gml:domainSet property describes the domain of the coverage and the gml:rangeSet property describes the range of the coverage."""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = True
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractCoverageType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coverage.xsd', 21, 1)
    _ElementMap = AbstractFeatureType._ElementMap.copy()
    _AttributeMap = AbstractFeatureType._AttributeMap.copy()
    # Base type is AbstractFeatureType
    
    # Element {http://www.opengis.net/gml/3.2}domainSet uses Python identifier domainSet
    __domainSet = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'domainSet'), 'domainSet', '__httpwww_opengis_netgml3_2_AbstractCoverageType_httpwww_opengis_netgml3_2domainSet', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coverage.xsd', 70, 1), )

    
    domainSet = property(__domainSet.value, __domainSet.set, None, 'The gml:domainSet property element describes the spatio-temporal region of interest, within which the coverage is defined. Its content model is given by gml:DomainSetType.\nThe value of the domain is thus a choice between a gml:AbstractGeometry and a gml:AbstractTimeObject.  In the instance these abstract elements will normally be substituted by a geometry complex or temporal complex, to represent spatial coverages and time-series, respectively.  \nThe presence of the gml:AssociationAttributeGroup means that domainSet follows the usual GML property model and may use the xlink:href attribute to point to the domain, as an alternative to describing the domain inline. Ownership semantics may be provided using the gml:OwnershipAttributeGroup.\n')

    
    # Element {http://www.opengis.net/gml/3.2}rangeSet uses Python identifier rangeSet
    __rangeSet = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'rangeSet'), 'rangeSet', '__httpwww_opengis_netgml3_2_AbstractCoverageType_httpwww_opengis_netgml3_2rangeSet', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coverage.xsd', 88, 1), )

    
    rangeSet = property(__rangeSet.value, __rangeSet.set, None, 'The gml:rangeSet property element contains the values of the coverage (sometimes called the attribute values).  Its content model is given by gml:RangeSetType.\nThis content model supports a structural description of the range.  The semantic information describing the range set is embedded using a uniform method, as part of the explicit values, or as a template value accompanying the representation using gml:DataBlock and gml:File.\nThe values from each component (or "band") in the range may be encoded within a gml:ValueArray element or a concrete member of the gml:AbstractScalarValueList substitution group . Use of these elements satisfies the value-type homogeneity requirement.')

    
    # Element metaDataProperty ({http://www.opengis.net/gml/3.2}metaDataProperty) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element location ({http://www.opengis.net/gml/3.2}location) inherited from {http://www.opengis.net/gml/3.2}AbstractFeatureType
    
    # Element boundedBy ({http://www.opengis.net/gml/3.2}boundedBy) inherited from {http://www.opengis.net/gml/3.2}AbstractFeatureType
    
    # Element description ({http://www.opengis.net/gml/3.2}description) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element descriptionReference ({http://www.opengis.net/gml/3.2}descriptionReference) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element name ({http://www.opengis.net/gml/3.2}name) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element identifier ({http://www.opengis.net/gml/3.2}identifier) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Attribute id inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    _ElementMap.update({
        __domainSet.name() : __domainSet,
        __rangeSet.name() : __rangeSet
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.AbstractCoverageType = AbstractCoverageType
_Namespace_gml.addCategoryObject('typeBinding', 'AbstractCoverageType', AbstractCoverageType)


# Complex type {http://www.opengis.net/gml/3.2}DomainSetType with content type ELEMENT_ONLY
class DomainSetType (pyxb.binding.basis.complexTypeDefinition):
    """Complex type {http://www.opengis.net/gml/3.2}DomainSetType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'DomainSetType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coverage.xsd', 78, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.opengis.net/gml/3.2}AbstractGeometry uses Python identifier AbstractGeometry
    __AbstractGeometry = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractGeometry'), 'AbstractGeometry', '__httpwww_opengis_netgml3_2_DomainSetType_httpwww_opengis_netgml3_2AbstractGeometry', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic0d1d.xsd', 50, 1), )

    
    AbstractGeometry = property(__AbstractGeometry.value, __AbstractGeometry.set, None, 'The AbstractGeometry element is the abstract head of the substitution group for all geometry elements of GML. This includes pre-defined and user-defined geometry elements. Any geometry element shall be a direct or indirect extension/restriction of AbstractGeometryType and shall be directly or indirectly in the substitution group of AbstractGeometry.')

    
    # Element {http://www.opengis.net/gml/3.2}AbstractTimeObject uses Python identifier AbstractTimeObject
    __AbstractTimeObject = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractTimeObject'), 'AbstractTimeObject', '__httpwww_opengis_netgml3_2_DomainSetType_httpwww_opengis_netgml3_2AbstractTimeObject', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporal.xsd', 18, 1), )

    
    AbstractTimeObject = property(__AbstractTimeObject.value, __AbstractTimeObject.set, None, 'gml:AbstractTimeObject acts as the head of a substitution group for all temporal primitives and complexes.')

    
    # Attribute {http://www.opengis.net/gml/3.2}remoteSchema uses Python identifier remoteSchema
    __remoteSchema = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gml, 'remoteSchema'), 'remoteSchema', '__httpwww_opengis_netgml3_2_DomainSetType_httpwww_opengis_netgml3_2remoteSchema', pyxb.binding.datatypes.anyURI)
    __remoteSchema._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 638, 1)
    __remoteSchema._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 52, 2)
    
    remoteSchema = property(__remoteSchema.value, __remoteSchema.set, None, '')

    
    # Attribute nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'nilReason'), 'nilReason', '__httpwww_opengis_netgml3_2_DomainSetType_nilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 51, 2)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 51, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    
    # Attribute owns uses Python identifier owns
    __owns = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'owns'), 'owns', '__httpwww_opengis_netgml3_2_DomainSetType_owns', pyxb.binding.datatypes.boolean, unicode_default='false')
    __owns._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 79, 2)
    __owns._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 79, 2)
    
    owns = property(__owns.value, __owns.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}type uses Python identifier type
    __type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'type'), 'type', '__httpwww_opengis_netgml3_2_DomainSetType_httpwww_w3_org1999xlinktype', _ImportedBinding_bindings_v1411_write__xlink.typeType, fixed=True, unicode_default='simple')
    __type._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 29, 1)
    __type._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 112, 2)
    
    type = property(__type.value, __type.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}href uses Python identifier href
    __href = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'href'), 'href', '__httpwww_opengis_netgml3_2_DomainSetType_httpwww_w3_org1999xlinkhref', _ImportedBinding_bindings_v1411_write__xlink.hrefType)
    __href._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 42, 1)
    __href._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 113, 2)
    
    href = property(__href.value, __href.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}role uses Python identifier role
    __role = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'role'), 'role', '__httpwww_opengis_netgml3_2_DomainSetType_httpwww_w3_org1999xlinkrole', _ImportedBinding_bindings_v1411_write__xlink.roleType)
    __role._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 48, 1)
    __role._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 114, 2)
    
    role = property(__role.value, __role.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}arcrole uses Python identifier arcrole
    __arcrole = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'arcrole'), 'arcrole', '__httpwww_opengis_netgml3_2_DomainSetType_httpwww_w3_org1999xlinkarcrole', _ImportedBinding_bindings_v1411_write__xlink.arcroleType)
    __arcrole._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 56, 1)
    __arcrole._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 115, 2)
    
    arcrole = property(__arcrole.value, __arcrole.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}title uses Python identifier title
    __title = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'title'), 'title', '__httpwww_opengis_netgml3_2_DomainSetType_httpwww_w3_org1999xlinktitle', _ImportedBinding_bindings_v1411_write__xlink.titleAttrType)
    __title._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 64, 1)
    __title._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 116, 2)
    
    title = property(__title.value, __title.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}show uses Python identifier show
    __show = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'show'), 'show', '__httpwww_opengis_netgml3_2_DomainSetType_httpwww_w3_org1999xlinkshow', _ImportedBinding_bindings_v1411_write__xlink.showType)
    __show._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 70, 1)
    __show._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 117, 2)
    
    show = property(__show.value, __show.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}actuate uses Python identifier actuate
    __actuate = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'actuate'), 'actuate', '__httpwww_opengis_netgml3_2_DomainSetType_httpwww_w3_org1999xlinkactuate', _ImportedBinding_bindings_v1411_write__xlink.actuateType)
    __actuate._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 82, 1)
    __actuate._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 118, 2)
    
    actuate = property(__actuate.value, __actuate.set, None, None)

    _ElementMap.update({
        __AbstractGeometry.name() : __AbstractGeometry,
        __AbstractTimeObject.name() : __AbstractTimeObject
    })
    _AttributeMap.update({
        __remoteSchema.name() : __remoteSchema,
        __nilReason.name() : __nilReason,
        __owns.name() : __owns,
        __type.name() : __type,
        __href.name() : __href,
        __role.name() : __role,
        __arcrole.name() : __arcrole,
        __title.name() : __title,
        __show.name() : __show,
        __actuate.name() : __actuate
    })
_module_typeBindings.DomainSetType = DomainSetType
_Namespace_gml.addCategoryObject('typeBinding', 'DomainSetType', DomainSetType)


# Complex type {http://www.opengis.net/gml/3.2}SequenceRuleType with content type SIMPLE
class SequenceRuleType (pyxb.binding.basis.complexTypeDefinition):
    """The gml:SequenceRuleType is derived from the gml:SequenceRuleEnumeration through the addition of an axisOrder attribute.  The gml:SequenceRuleEnumeration is an enumerated type. The rule names are defined in ISO 19123. If no rule name is specified the default is "Linear"."""
    _TypeDefinition = SequenceRuleEnumeration
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_SIMPLE
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'SequenceRuleType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coverage.xsd', 197, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is SequenceRuleEnumeration
    
    # Attribute order uses Python identifier order
    __order = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'order'), 'order', '__httpwww_opengis_netgml3_2_SequenceRuleType_order', _module_typeBindings.IncrementOrder)
    __order._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coverage.xsd', 203, 4)
    __order._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coverage.xsd', 203, 4)
    
    order = property(__order.value, __order.set, None, '')

    
    # Attribute axisOrder uses Python identifier axisOrder
    __axisOrder = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'axisOrder'), 'axisOrder', '__httpwww_opengis_netgml3_2_SequenceRuleType_axisOrder', _module_typeBindings.AxisDirectionList)
    __axisOrder._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coverage.xsd', 208, 4)
    __axisOrder._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coverage.xsd', 208, 4)
    
    axisOrder = property(__axisOrder.value, __axisOrder.set, None, None)

    _ElementMap.update({
        
    })
    _AttributeMap.update({
        __order.name() : __order,
        __axisOrder.name() : __axisOrder
    })
_module_typeBindings.SequenceRuleType = SequenceRuleType
_Namespace_gml.addCategoryObject('typeBinding', 'SequenceRuleType', SequenceRuleType)


# Complex type {http://www.opengis.net/gml/3.2}DatumPropertyType with content type ELEMENT_ONLY
class DatumPropertyType (pyxb.binding.basis.complexTypeDefinition):
    """gml:DatumPropertyType is a property type for association roles to a datum, either referencing or containing the definition of that datum."""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'DatumPropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/datums.xsd', 52, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.opengis.net/gml/3.2}AbstractDatum uses Python identifier AbstractDatum
    __AbstractDatum = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractDatum'), 'AbstractDatum', '__httpwww_opengis_netgml3_2_DatumPropertyType_httpwww_opengis_netgml3_2AbstractDatum', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/datums.xsd', 21, 1), )

    
    AbstractDatum = property(__AbstractDatum.value, __AbstractDatum.set, None, 'A gml:AbstractDatum specifies the relationship of a coordinate system to the earth, thus creating a coordinate reference system. A datum uses a parameter or set of parameters that determine the location of the origin of the coordinate reference system. Each datum subtype may be associated with only specific types of coordinate systems. This abstract complex type shall not be used, extended, or restricted, in a GML Application Schema, to define a concrete subtype with a meaning equivalent to a concrete subtype specified in this document.')

    
    # Attribute {http://www.opengis.net/gml/3.2}remoteSchema uses Python identifier remoteSchema
    __remoteSchema = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gml, 'remoteSchema'), 'remoteSchema', '__httpwww_opengis_netgml3_2_DatumPropertyType_httpwww_opengis_netgml3_2remoteSchema', pyxb.binding.datatypes.anyURI)
    __remoteSchema._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 638, 1)
    __remoteSchema._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 52, 2)
    
    remoteSchema = property(__remoteSchema.value, __remoteSchema.set, None, '')

    
    # Attribute nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'nilReason'), 'nilReason', '__httpwww_opengis_netgml3_2_DatumPropertyType_nilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 51, 2)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 51, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}type uses Python identifier type
    __type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'type'), 'type', '__httpwww_opengis_netgml3_2_DatumPropertyType_httpwww_w3_org1999xlinktype', _ImportedBinding_bindings_v1411_write__xlink.typeType, fixed=True, unicode_default='simple')
    __type._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 29, 1)
    __type._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 112, 2)
    
    type = property(__type.value, __type.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}href uses Python identifier href
    __href = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'href'), 'href', '__httpwww_opengis_netgml3_2_DatumPropertyType_httpwww_w3_org1999xlinkhref', _ImportedBinding_bindings_v1411_write__xlink.hrefType)
    __href._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 42, 1)
    __href._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 113, 2)
    
    href = property(__href.value, __href.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}role uses Python identifier role
    __role = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'role'), 'role', '__httpwww_opengis_netgml3_2_DatumPropertyType_httpwww_w3_org1999xlinkrole', _ImportedBinding_bindings_v1411_write__xlink.roleType)
    __role._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 48, 1)
    __role._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 114, 2)
    
    role = property(__role.value, __role.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}arcrole uses Python identifier arcrole
    __arcrole = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'arcrole'), 'arcrole', '__httpwww_opengis_netgml3_2_DatumPropertyType_httpwww_w3_org1999xlinkarcrole', _ImportedBinding_bindings_v1411_write__xlink.arcroleType)
    __arcrole._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 56, 1)
    __arcrole._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 115, 2)
    
    arcrole = property(__arcrole.value, __arcrole.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}title uses Python identifier title
    __title = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'title'), 'title', '__httpwww_opengis_netgml3_2_DatumPropertyType_httpwww_w3_org1999xlinktitle', _ImportedBinding_bindings_v1411_write__xlink.titleAttrType)
    __title._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 64, 1)
    __title._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 116, 2)
    
    title = property(__title.value, __title.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}show uses Python identifier show
    __show = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'show'), 'show', '__httpwww_opengis_netgml3_2_DatumPropertyType_httpwww_w3_org1999xlinkshow', _ImportedBinding_bindings_v1411_write__xlink.showType)
    __show._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 70, 1)
    __show._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 117, 2)
    
    show = property(__show.value, __show.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}actuate uses Python identifier actuate
    __actuate = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'actuate'), 'actuate', '__httpwww_opengis_netgml3_2_DatumPropertyType_httpwww_w3_org1999xlinkactuate', _ImportedBinding_bindings_v1411_write__xlink.actuateType)
    __actuate._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 82, 1)
    __actuate._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 118, 2)
    
    actuate = property(__actuate.value, __actuate.set, None, None)

    _ElementMap.update({
        __AbstractDatum.name() : __AbstractDatum
    })
    _AttributeMap.update({
        __remoteSchema.name() : __remoteSchema,
        __nilReason.name() : __nilReason,
        __type.name() : __type,
        __href.name() : __href,
        __role.name() : __role,
        __arcrole.name() : __arcrole,
        __title.name() : __title,
        __show.name() : __show,
        __actuate.name() : __actuate
    })
_module_typeBindings.DatumPropertyType = DatumPropertyType
_Namespace_gml.addCategoryObject('typeBinding', 'DatumPropertyType', DatumPropertyType)


# Complex type {http://www.opengis.net/gml/3.2}GeodeticDatumPropertyType with content type ELEMENT_ONLY
class GeodeticDatumPropertyType (pyxb.binding.basis.complexTypeDefinition):
    """gml:GeodeticDatumPropertyType is a property type for association roles to a geodetic datum, either referencing or containing the definition of that datum."""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'GeodeticDatumPropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/datums.xsd', 86, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.opengis.net/gml/3.2}GeodeticDatum uses Python identifier GeodeticDatum
    __GeodeticDatum = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'GeodeticDatum'), 'GeodeticDatum', '__httpwww_opengis_netgml3_2_GeodeticDatumPropertyType_httpwww_opengis_netgml3_2GeodeticDatum', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/datums.xsd', 61, 1), )

    
    GeodeticDatum = property(__GeodeticDatum.value, __GeodeticDatum.set, None, 'gml:GeodeticDatum is a geodetic datum defines the precise location and orientation in 3-dimensional space of a defined ellipsoid (or sphere), or of a Cartesian coordinate system centered in this ellipsoid (or sphere).')

    
    # Attribute {http://www.opengis.net/gml/3.2}remoteSchema uses Python identifier remoteSchema
    __remoteSchema = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gml, 'remoteSchema'), 'remoteSchema', '__httpwww_opengis_netgml3_2_GeodeticDatumPropertyType_httpwww_opengis_netgml3_2remoteSchema', pyxb.binding.datatypes.anyURI)
    __remoteSchema._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 638, 1)
    __remoteSchema._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 52, 2)
    
    remoteSchema = property(__remoteSchema.value, __remoteSchema.set, None, '')

    
    # Attribute nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'nilReason'), 'nilReason', '__httpwww_opengis_netgml3_2_GeodeticDatumPropertyType_nilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 51, 2)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 51, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}type uses Python identifier type
    __type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'type'), 'type', '__httpwww_opengis_netgml3_2_GeodeticDatumPropertyType_httpwww_w3_org1999xlinktype', _ImportedBinding_bindings_v1411_write__xlink.typeType, fixed=True, unicode_default='simple')
    __type._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 29, 1)
    __type._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 112, 2)
    
    type = property(__type.value, __type.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}href uses Python identifier href
    __href = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'href'), 'href', '__httpwww_opengis_netgml3_2_GeodeticDatumPropertyType_httpwww_w3_org1999xlinkhref', _ImportedBinding_bindings_v1411_write__xlink.hrefType)
    __href._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 42, 1)
    __href._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 113, 2)
    
    href = property(__href.value, __href.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}role uses Python identifier role
    __role = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'role'), 'role', '__httpwww_opengis_netgml3_2_GeodeticDatumPropertyType_httpwww_w3_org1999xlinkrole', _ImportedBinding_bindings_v1411_write__xlink.roleType)
    __role._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 48, 1)
    __role._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 114, 2)
    
    role = property(__role.value, __role.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}arcrole uses Python identifier arcrole
    __arcrole = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'arcrole'), 'arcrole', '__httpwww_opengis_netgml3_2_GeodeticDatumPropertyType_httpwww_w3_org1999xlinkarcrole', _ImportedBinding_bindings_v1411_write__xlink.arcroleType)
    __arcrole._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 56, 1)
    __arcrole._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 115, 2)
    
    arcrole = property(__arcrole.value, __arcrole.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}title uses Python identifier title
    __title = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'title'), 'title', '__httpwww_opengis_netgml3_2_GeodeticDatumPropertyType_httpwww_w3_org1999xlinktitle', _ImportedBinding_bindings_v1411_write__xlink.titleAttrType)
    __title._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 64, 1)
    __title._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 116, 2)
    
    title = property(__title.value, __title.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}show uses Python identifier show
    __show = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'show'), 'show', '__httpwww_opengis_netgml3_2_GeodeticDatumPropertyType_httpwww_w3_org1999xlinkshow', _ImportedBinding_bindings_v1411_write__xlink.showType)
    __show._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 70, 1)
    __show._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 117, 2)
    
    show = property(__show.value, __show.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}actuate uses Python identifier actuate
    __actuate = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'actuate'), 'actuate', '__httpwww_opengis_netgml3_2_GeodeticDatumPropertyType_httpwww_w3_org1999xlinkactuate', _ImportedBinding_bindings_v1411_write__xlink.actuateType)
    __actuate._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 82, 1)
    __actuate._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 118, 2)
    
    actuate = property(__actuate.value, __actuate.set, None, None)

    _ElementMap.update({
        __GeodeticDatum.name() : __GeodeticDatum
    })
    _AttributeMap.update({
        __remoteSchema.name() : __remoteSchema,
        __nilReason.name() : __nilReason,
        __type.name() : __type,
        __href.name() : __href,
        __role.name() : __role,
        __arcrole.name() : __arcrole,
        __title.name() : __title,
        __show.name() : __show,
        __actuate.name() : __actuate
    })
_module_typeBindings.GeodeticDatumPropertyType = GeodeticDatumPropertyType
_Namespace_gml.addCategoryObject('typeBinding', 'GeodeticDatumPropertyType', GeodeticDatumPropertyType)


# Complex type {http://www.opengis.net/gml/3.2}EllipsoidPropertyType with content type ELEMENT_ONLY
class EllipsoidPropertyType (pyxb.binding.basis.complexTypeDefinition):
    """gml:EllipsoidPropertyType is a property type for association roles to an ellipsoid, either referencing or containing the definition of that ellipsoid."""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'EllipsoidPropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/datums.xsd', 136, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.opengis.net/gml/3.2}Ellipsoid uses Python identifier Ellipsoid
    __Ellipsoid = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'Ellipsoid'), 'Ellipsoid', '__httpwww_opengis_netgml3_2_EllipsoidPropertyType_httpwww_opengis_netgml3_2Ellipsoid', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/datums.xsd', 95, 1), )

    
    Ellipsoid = property(__Ellipsoid.value, __Ellipsoid.set, None, 'A gml:Ellipsoid is a geometric figure that may be used to describe the approximate shape of the earth. In mathematical terms, it is a surface formed by the rotation of an ellipse about its minor axis.')

    
    # Attribute {http://www.opengis.net/gml/3.2}remoteSchema uses Python identifier remoteSchema
    __remoteSchema = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gml, 'remoteSchema'), 'remoteSchema', '__httpwww_opengis_netgml3_2_EllipsoidPropertyType_httpwww_opengis_netgml3_2remoteSchema', pyxb.binding.datatypes.anyURI)
    __remoteSchema._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 638, 1)
    __remoteSchema._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 52, 2)
    
    remoteSchema = property(__remoteSchema.value, __remoteSchema.set, None, '')

    
    # Attribute nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'nilReason'), 'nilReason', '__httpwww_opengis_netgml3_2_EllipsoidPropertyType_nilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 51, 2)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 51, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}type uses Python identifier type
    __type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'type'), 'type', '__httpwww_opengis_netgml3_2_EllipsoidPropertyType_httpwww_w3_org1999xlinktype', _ImportedBinding_bindings_v1411_write__xlink.typeType, fixed=True, unicode_default='simple')
    __type._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 29, 1)
    __type._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 112, 2)
    
    type = property(__type.value, __type.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}href uses Python identifier href
    __href = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'href'), 'href', '__httpwww_opengis_netgml3_2_EllipsoidPropertyType_httpwww_w3_org1999xlinkhref', _ImportedBinding_bindings_v1411_write__xlink.hrefType)
    __href._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 42, 1)
    __href._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 113, 2)
    
    href = property(__href.value, __href.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}role uses Python identifier role
    __role = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'role'), 'role', '__httpwww_opengis_netgml3_2_EllipsoidPropertyType_httpwww_w3_org1999xlinkrole', _ImportedBinding_bindings_v1411_write__xlink.roleType)
    __role._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 48, 1)
    __role._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 114, 2)
    
    role = property(__role.value, __role.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}arcrole uses Python identifier arcrole
    __arcrole = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'arcrole'), 'arcrole', '__httpwww_opengis_netgml3_2_EllipsoidPropertyType_httpwww_w3_org1999xlinkarcrole', _ImportedBinding_bindings_v1411_write__xlink.arcroleType)
    __arcrole._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 56, 1)
    __arcrole._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 115, 2)
    
    arcrole = property(__arcrole.value, __arcrole.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}title uses Python identifier title
    __title = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'title'), 'title', '__httpwww_opengis_netgml3_2_EllipsoidPropertyType_httpwww_w3_org1999xlinktitle', _ImportedBinding_bindings_v1411_write__xlink.titleAttrType)
    __title._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 64, 1)
    __title._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 116, 2)
    
    title = property(__title.value, __title.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}show uses Python identifier show
    __show = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'show'), 'show', '__httpwww_opengis_netgml3_2_EllipsoidPropertyType_httpwww_w3_org1999xlinkshow', _ImportedBinding_bindings_v1411_write__xlink.showType)
    __show._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 70, 1)
    __show._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 117, 2)
    
    show = property(__show.value, __show.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}actuate uses Python identifier actuate
    __actuate = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'actuate'), 'actuate', '__httpwww_opengis_netgml3_2_EllipsoidPropertyType_httpwww_w3_org1999xlinkactuate', _ImportedBinding_bindings_v1411_write__xlink.actuateType)
    __actuate._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 82, 1)
    __actuate._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 118, 2)
    
    actuate = property(__actuate.value, __actuate.set, None, None)

    _ElementMap.update({
        __Ellipsoid.name() : __Ellipsoid
    })
    _AttributeMap.update({
        __remoteSchema.name() : __remoteSchema,
        __nilReason.name() : __nilReason,
        __type.name() : __type,
        __href.name() : __href,
        __role.name() : __role,
        __arcrole.name() : __arcrole,
        __title.name() : __title,
        __show.name() : __show,
        __actuate.name() : __actuate
    })
_module_typeBindings.EllipsoidPropertyType = EllipsoidPropertyType
_Namespace_gml.addCategoryObject('typeBinding', 'EllipsoidPropertyType', EllipsoidPropertyType)


# Complex type {http://www.opengis.net/gml/3.2}PrimeMeridianPropertyType with content type ELEMENT_ONLY
class PrimeMeridianPropertyType (pyxb.binding.basis.complexTypeDefinition):
    """gml:PrimeMeridianPropertyType is a property type for association roles to a prime meridian, either referencing or containing the definition of that meridian."""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'PrimeMeridianPropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/datums.xsd', 164, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.opengis.net/gml/3.2}PrimeMeridian uses Python identifier PrimeMeridian
    __PrimeMeridian = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'PrimeMeridian'), 'PrimeMeridian', '__httpwww_opengis_netgml3_2_PrimeMeridianPropertyType_httpwww_opengis_netgml3_2PrimeMeridian', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/datums.xsd', 145, 1), )

    
    PrimeMeridian = property(__PrimeMeridian.value, __PrimeMeridian.set, None, 'A gml:PrimeMeridian defines the origin from which longitude values are determined. The default value for the prime meridian gml:identifier value is "Greenwich".')

    
    # Attribute {http://www.opengis.net/gml/3.2}remoteSchema uses Python identifier remoteSchema
    __remoteSchema = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gml, 'remoteSchema'), 'remoteSchema', '__httpwww_opengis_netgml3_2_PrimeMeridianPropertyType_httpwww_opengis_netgml3_2remoteSchema', pyxb.binding.datatypes.anyURI)
    __remoteSchema._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 638, 1)
    __remoteSchema._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 52, 2)
    
    remoteSchema = property(__remoteSchema.value, __remoteSchema.set, None, '')

    
    # Attribute nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'nilReason'), 'nilReason', '__httpwww_opengis_netgml3_2_PrimeMeridianPropertyType_nilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 51, 2)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 51, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}type uses Python identifier type
    __type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'type'), 'type', '__httpwww_opengis_netgml3_2_PrimeMeridianPropertyType_httpwww_w3_org1999xlinktype', _ImportedBinding_bindings_v1411_write__xlink.typeType, fixed=True, unicode_default='simple')
    __type._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 29, 1)
    __type._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 112, 2)
    
    type = property(__type.value, __type.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}href uses Python identifier href
    __href = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'href'), 'href', '__httpwww_opengis_netgml3_2_PrimeMeridianPropertyType_httpwww_w3_org1999xlinkhref', _ImportedBinding_bindings_v1411_write__xlink.hrefType)
    __href._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 42, 1)
    __href._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 113, 2)
    
    href = property(__href.value, __href.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}role uses Python identifier role
    __role = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'role'), 'role', '__httpwww_opengis_netgml3_2_PrimeMeridianPropertyType_httpwww_w3_org1999xlinkrole', _ImportedBinding_bindings_v1411_write__xlink.roleType)
    __role._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 48, 1)
    __role._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 114, 2)
    
    role = property(__role.value, __role.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}arcrole uses Python identifier arcrole
    __arcrole = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'arcrole'), 'arcrole', '__httpwww_opengis_netgml3_2_PrimeMeridianPropertyType_httpwww_w3_org1999xlinkarcrole', _ImportedBinding_bindings_v1411_write__xlink.arcroleType)
    __arcrole._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 56, 1)
    __arcrole._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 115, 2)
    
    arcrole = property(__arcrole.value, __arcrole.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}title uses Python identifier title
    __title = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'title'), 'title', '__httpwww_opengis_netgml3_2_PrimeMeridianPropertyType_httpwww_w3_org1999xlinktitle', _ImportedBinding_bindings_v1411_write__xlink.titleAttrType)
    __title._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 64, 1)
    __title._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 116, 2)
    
    title = property(__title.value, __title.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}show uses Python identifier show
    __show = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'show'), 'show', '__httpwww_opengis_netgml3_2_PrimeMeridianPropertyType_httpwww_w3_org1999xlinkshow', _ImportedBinding_bindings_v1411_write__xlink.showType)
    __show._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 70, 1)
    __show._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 117, 2)
    
    show = property(__show.value, __show.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}actuate uses Python identifier actuate
    __actuate = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'actuate'), 'actuate', '__httpwww_opengis_netgml3_2_PrimeMeridianPropertyType_httpwww_w3_org1999xlinkactuate', _ImportedBinding_bindings_v1411_write__xlink.actuateType)
    __actuate._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 82, 1)
    __actuate._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 118, 2)
    
    actuate = property(__actuate.value, __actuate.set, None, None)

    _ElementMap.update({
        __PrimeMeridian.name() : __PrimeMeridian
    })
    _AttributeMap.update({
        __remoteSchema.name() : __remoteSchema,
        __nilReason.name() : __nilReason,
        __type.name() : __type,
        __href.name() : __href,
        __role.name() : __role,
        __arcrole.name() : __arcrole,
        __title.name() : __title,
        __show.name() : __show,
        __actuate.name() : __actuate
    })
_module_typeBindings.PrimeMeridianPropertyType = PrimeMeridianPropertyType
_Namespace_gml.addCategoryObject('typeBinding', 'PrimeMeridianPropertyType', PrimeMeridianPropertyType)


# Complex type {http://www.opengis.net/gml/3.2}EngineeringDatumPropertyType with content type ELEMENT_ONLY
class EngineeringDatumPropertyType (pyxb.binding.basis.complexTypeDefinition):
    """gml:EngineeringDatumPropertyType is a property type for association roles to an engineering datum, either referencing or containing the definition of that datum."""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'EngineeringDatumPropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/datums.xsd', 183, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.opengis.net/gml/3.2}EngineeringDatum uses Python identifier EngineeringDatum
    __EngineeringDatum = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'EngineeringDatum'), 'EngineeringDatum', '__httpwww_opengis_netgml3_2_EngineeringDatumPropertyType_httpwww_opengis_netgml3_2EngineeringDatum', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/datums.xsd', 173, 1), )

    
    EngineeringDatum = property(__EngineeringDatum.value, __EngineeringDatum.set, None, 'gml:EngineeringDatum defines the origin of an engineering coordinate reference system, and is used in a region around that origin. This origin may be fixed with respect to the earth (such as a defined point at a construction site), or be a defined point on a moving vehicle (such as on a ship or satellite).')

    
    # Attribute {http://www.opengis.net/gml/3.2}remoteSchema uses Python identifier remoteSchema
    __remoteSchema = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gml, 'remoteSchema'), 'remoteSchema', '__httpwww_opengis_netgml3_2_EngineeringDatumPropertyType_httpwww_opengis_netgml3_2remoteSchema', pyxb.binding.datatypes.anyURI)
    __remoteSchema._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 638, 1)
    __remoteSchema._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 52, 2)
    
    remoteSchema = property(__remoteSchema.value, __remoteSchema.set, None, '')

    
    # Attribute nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'nilReason'), 'nilReason', '__httpwww_opengis_netgml3_2_EngineeringDatumPropertyType_nilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 51, 2)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 51, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}type uses Python identifier type
    __type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'type'), 'type', '__httpwww_opengis_netgml3_2_EngineeringDatumPropertyType_httpwww_w3_org1999xlinktype', _ImportedBinding_bindings_v1411_write__xlink.typeType, fixed=True, unicode_default='simple')
    __type._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 29, 1)
    __type._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 112, 2)
    
    type = property(__type.value, __type.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}href uses Python identifier href
    __href = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'href'), 'href', '__httpwww_opengis_netgml3_2_EngineeringDatumPropertyType_httpwww_w3_org1999xlinkhref', _ImportedBinding_bindings_v1411_write__xlink.hrefType)
    __href._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 42, 1)
    __href._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 113, 2)
    
    href = property(__href.value, __href.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}role uses Python identifier role
    __role = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'role'), 'role', '__httpwww_opengis_netgml3_2_EngineeringDatumPropertyType_httpwww_w3_org1999xlinkrole', _ImportedBinding_bindings_v1411_write__xlink.roleType)
    __role._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 48, 1)
    __role._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 114, 2)
    
    role = property(__role.value, __role.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}arcrole uses Python identifier arcrole
    __arcrole = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'arcrole'), 'arcrole', '__httpwww_opengis_netgml3_2_EngineeringDatumPropertyType_httpwww_w3_org1999xlinkarcrole', _ImportedBinding_bindings_v1411_write__xlink.arcroleType)
    __arcrole._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 56, 1)
    __arcrole._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 115, 2)
    
    arcrole = property(__arcrole.value, __arcrole.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}title uses Python identifier title
    __title = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'title'), 'title', '__httpwww_opengis_netgml3_2_EngineeringDatumPropertyType_httpwww_w3_org1999xlinktitle', _ImportedBinding_bindings_v1411_write__xlink.titleAttrType)
    __title._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 64, 1)
    __title._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 116, 2)
    
    title = property(__title.value, __title.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}show uses Python identifier show
    __show = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'show'), 'show', '__httpwww_opengis_netgml3_2_EngineeringDatumPropertyType_httpwww_w3_org1999xlinkshow', _ImportedBinding_bindings_v1411_write__xlink.showType)
    __show._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 70, 1)
    __show._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 117, 2)
    
    show = property(__show.value, __show.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}actuate uses Python identifier actuate
    __actuate = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'actuate'), 'actuate', '__httpwww_opengis_netgml3_2_EngineeringDatumPropertyType_httpwww_w3_org1999xlinkactuate', _ImportedBinding_bindings_v1411_write__xlink.actuateType)
    __actuate._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 82, 1)
    __actuate._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 118, 2)
    
    actuate = property(__actuate.value, __actuate.set, None, None)

    _ElementMap.update({
        __EngineeringDatum.name() : __EngineeringDatum
    })
    _AttributeMap.update({
        __remoteSchema.name() : __remoteSchema,
        __nilReason.name() : __nilReason,
        __type.name() : __type,
        __href.name() : __href,
        __role.name() : __role,
        __arcrole.name() : __arcrole,
        __title.name() : __title,
        __show.name() : __show,
        __actuate.name() : __actuate
    })
_module_typeBindings.EngineeringDatumPropertyType = EngineeringDatumPropertyType
_Namespace_gml.addCategoryObject('typeBinding', 'EngineeringDatumPropertyType', EngineeringDatumPropertyType)


# Complex type {http://www.opengis.net/gml/3.2}ImageDatumPropertyType with content type ELEMENT_ONLY
class ImageDatumPropertyType (pyxb.binding.basis.complexTypeDefinition):
    """gml:ImageDatumPropertyType is a property type for association roles to an image datum, either referencing or containing the definition of that datum."""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'ImageDatumPropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/datums.xsd', 211, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.opengis.net/gml/3.2}ImageDatum uses Python identifier ImageDatum
    __ImageDatum = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'ImageDatum'), 'ImageDatum', '__httpwww_opengis_netgml3_2_ImageDatumPropertyType_httpwww_opengis_netgml3_2ImageDatum', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/datums.xsd', 192, 1), )

    
    ImageDatum = property(__ImageDatum.value, __ImageDatum.set, None, 'gml:ImageDatum defines the origin of an image coordinate reference system, and is used in a local context only. For an image datum, the anchor definition is usually either the centre of the image or the corner of the image. For more information, see ISO 19111 B.3.5.')

    
    # Attribute {http://www.opengis.net/gml/3.2}remoteSchema uses Python identifier remoteSchema
    __remoteSchema = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gml, 'remoteSchema'), 'remoteSchema', '__httpwww_opengis_netgml3_2_ImageDatumPropertyType_httpwww_opengis_netgml3_2remoteSchema', pyxb.binding.datatypes.anyURI)
    __remoteSchema._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 638, 1)
    __remoteSchema._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 52, 2)
    
    remoteSchema = property(__remoteSchema.value, __remoteSchema.set, None, '')

    
    # Attribute nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'nilReason'), 'nilReason', '__httpwww_opengis_netgml3_2_ImageDatumPropertyType_nilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 51, 2)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 51, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}type uses Python identifier type
    __type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'type'), 'type', '__httpwww_opengis_netgml3_2_ImageDatumPropertyType_httpwww_w3_org1999xlinktype', _ImportedBinding_bindings_v1411_write__xlink.typeType, fixed=True, unicode_default='simple')
    __type._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 29, 1)
    __type._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 112, 2)
    
    type = property(__type.value, __type.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}href uses Python identifier href
    __href = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'href'), 'href', '__httpwww_opengis_netgml3_2_ImageDatumPropertyType_httpwww_w3_org1999xlinkhref', _ImportedBinding_bindings_v1411_write__xlink.hrefType)
    __href._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 42, 1)
    __href._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 113, 2)
    
    href = property(__href.value, __href.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}role uses Python identifier role
    __role = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'role'), 'role', '__httpwww_opengis_netgml3_2_ImageDatumPropertyType_httpwww_w3_org1999xlinkrole', _ImportedBinding_bindings_v1411_write__xlink.roleType)
    __role._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 48, 1)
    __role._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 114, 2)
    
    role = property(__role.value, __role.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}arcrole uses Python identifier arcrole
    __arcrole = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'arcrole'), 'arcrole', '__httpwww_opengis_netgml3_2_ImageDatumPropertyType_httpwww_w3_org1999xlinkarcrole', _ImportedBinding_bindings_v1411_write__xlink.arcroleType)
    __arcrole._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 56, 1)
    __arcrole._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 115, 2)
    
    arcrole = property(__arcrole.value, __arcrole.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}title uses Python identifier title
    __title = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'title'), 'title', '__httpwww_opengis_netgml3_2_ImageDatumPropertyType_httpwww_w3_org1999xlinktitle', _ImportedBinding_bindings_v1411_write__xlink.titleAttrType)
    __title._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 64, 1)
    __title._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 116, 2)
    
    title = property(__title.value, __title.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}show uses Python identifier show
    __show = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'show'), 'show', '__httpwww_opengis_netgml3_2_ImageDatumPropertyType_httpwww_w3_org1999xlinkshow', _ImportedBinding_bindings_v1411_write__xlink.showType)
    __show._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 70, 1)
    __show._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 117, 2)
    
    show = property(__show.value, __show.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}actuate uses Python identifier actuate
    __actuate = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'actuate'), 'actuate', '__httpwww_opengis_netgml3_2_ImageDatumPropertyType_httpwww_w3_org1999xlinkactuate', _ImportedBinding_bindings_v1411_write__xlink.actuateType)
    __actuate._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 82, 1)
    __actuate._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 118, 2)
    
    actuate = property(__actuate.value, __actuate.set, None, None)

    _ElementMap.update({
        __ImageDatum.name() : __ImageDatum
    })
    _AttributeMap.update({
        __remoteSchema.name() : __remoteSchema,
        __nilReason.name() : __nilReason,
        __type.name() : __type,
        __href.name() : __href,
        __role.name() : __role,
        __arcrole.name() : __arcrole,
        __title.name() : __title,
        __show.name() : __show,
        __actuate.name() : __actuate
    })
_module_typeBindings.ImageDatumPropertyType = ImageDatumPropertyType
_Namespace_gml.addCategoryObject('typeBinding', 'ImageDatumPropertyType', ImageDatumPropertyType)


# Complex type {http://www.opengis.net/gml/3.2}VerticalDatumPropertyType with content type ELEMENT_ONLY
class VerticalDatumPropertyType (pyxb.binding.basis.complexTypeDefinition):
    """gml:VerticalDatumPropertyType is property type for association roles to a vertical datum, either referencing or containing the definition of that datum."""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'VerticalDatumPropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/datums.xsd', 230, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.opengis.net/gml/3.2}VerticalDatum uses Python identifier VerticalDatum
    __VerticalDatum = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'VerticalDatum'), 'VerticalDatum', '__httpwww_opengis_netgml3_2_VerticalDatumPropertyType_httpwww_opengis_netgml3_2VerticalDatum', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/datums.xsd', 220, 1), )

    
    VerticalDatum = property(__VerticalDatum.value, __VerticalDatum.set, None, 'gml:VerticalDatum is a textual description and/or a set of parameters identifying a particular reference level surface used as a zero-height surface, including its position with respect to the Earth for any of the height types recognized by this International Standard.')

    
    # Attribute {http://www.opengis.net/gml/3.2}remoteSchema uses Python identifier remoteSchema
    __remoteSchema = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gml, 'remoteSchema'), 'remoteSchema', '__httpwww_opengis_netgml3_2_VerticalDatumPropertyType_httpwww_opengis_netgml3_2remoteSchema', pyxb.binding.datatypes.anyURI)
    __remoteSchema._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 638, 1)
    __remoteSchema._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 52, 2)
    
    remoteSchema = property(__remoteSchema.value, __remoteSchema.set, None, '')

    
    # Attribute nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'nilReason'), 'nilReason', '__httpwww_opengis_netgml3_2_VerticalDatumPropertyType_nilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 51, 2)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 51, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}type uses Python identifier type
    __type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'type'), 'type', '__httpwww_opengis_netgml3_2_VerticalDatumPropertyType_httpwww_w3_org1999xlinktype', _ImportedBinding_bindings_v1411_write__xlink.typeType, fixed=True, unicode_default='simple')
    __type._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 29, 1)
    __type._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 112, 2)
    
    type = property(__type.value, __type.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}href uses Python identifier href
    __href = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'href'), 'href', '__httpwww_opengis_netgml3_2_VerticalDatumPropertyType_httpwww_w3_org1999xlinkhref', _ImportedBinding_bindings_v1411_write__xlink.hrefType)
    __href._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 42, 1)
    __href._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 113, 2)
    
    href = property(__href.value, __href.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}role uses Python identifier role
    __role = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'role'), 'role', '__httpwww_opengis_netgml3_2_VerticalDatumPropertyType_httpwww_w3_org1999xlinkrole', _ImportedBinding_bindings_v1411_write__xlink.roleType)
    __role._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 48, 1)
    __role._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 114, 2)
    
    role = property(__role.value, __role.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}arcrole uses Python identifier arcrole
    __arcrole = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'arcrole'), 'arcrole', '__httpwww_opengis_netgml3_2_VerticalDatumPropertyType_httpwww_w3_org1999xlinkarcrole', _ImportedBinding_bindings_v1411_write__xlink.arcroleType)
    __arcrole._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 56, 1)
    __arcrole._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 115, 2)
    
    arcrole = property(__arcrole.value, __arcrole.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}title uses Python identifier title
    __title = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'title'), 'title', '__httpwww_opengis_netgml3_2_VerticalDatumPropertyType_httpwww_w3_org1999xlinktitle', _ImportedBinding_bindings_v1411_write__xlink.titleAttrType)
    __title._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 64, 1)
    __title._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 116, 2)
    
    title = property(__title.value, __title.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}show uses Python identifier show
    __show = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'show'), 'show', '__httpwww_opengis_netgml3_2_VerticalDatumPropertyType_httpwww_w3_org1999xlinkshow', _ImportedBinding_bindings_v1411_write__xlink.showType)
    __show._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 70, 1)
    __show._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 117, 2)
    
    show = property(__show.value, __show.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}actuate uses Python identifier actuate
    __actuate = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'actuate'), 'actuate', '__httpwww_opengis_netgml3_2_VerticalDatumPropertyType_httpwww_w3_org1999xlinkactuate', _ImportedBinding_bindings_v1411_write__xlink.actuateType)
    __actuate._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 82, 1)
    __actuate._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 118, 2)
    
    actuate = property(__actuate.value, __actuate.set, None, None)

    _ElementMap.update({
        __VerticalDatum.name() : __VerticalDatum
    })
    _AttributeMap.update({
        __remoteSchema.name() : __remoteSchema,
        __nilReason.name() : __nilReason,
        __type.name() : __type,
        __href.name() : __href,
        __role.name() : __role,
        __arcrole.name() : __arcrole,
        __title.name() : __title,
        __show.name() : __show,
        __actuate.name() : __actuate
    })
_module_typeBindings.VerticalDatumPropertyType = VerticalDatumPropertyType
_Namespace_gml.addCategoryObject('typeBinding', 'VerticalDatumPropertyType', VerticalDatumPropertyType)


# Complex type {http://www.opengis.net/gml/3.2}TemporalDatumPropertyType with content type ELEMENT_ONLY
class TemporalDatumPropertyType (pyxb.binding.basis.complexTypeDefinition):
    """gml:TemporalDatumPropertyType is a property type for association roles to a temporal datum, either referencing or containing the definition of that datum."""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'TemporalDatumPropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/datums.xsd', 278, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.opengis.net/gml/3.2}TemporalDatum uses Python identifier TemporalDatum
    __TemporalDatum = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'TemporalDatum'), 'TemporalDatum', '__httpwww_opengis_netgml3_2_TemporalDatumPropertyType_httpwww_opengis_netgml3_2TemporalDatum', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/datums.xsd', 239, 1), )

    
    TemporalDatum = property(__TemporalDatum.value, __TemporalDatum.set, None, 'A gml:TemporalDatum defines the origin of a Temporal Reference System. This type omits the "anchorDefinition" and "realizationEpoch" elements and adds the "origin" element with the dateTime type.')

    
    # Attribute {http://www.opengis.net/gml/3.2}remoteSchema uses Python identifier remoteSchema
    __remoteSchema = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gml, 'remoteSchema'), 'remoteSchema', '__httpwww_opengis_netgml3_2_TemporalDatumPropertyType_httpwww_opengis_netgml3_2remoteSchema', pyxb.binding.datatypes.anyURI)
    __remoteSchema._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 638, 1)
    __remoteSchema._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 52, 2)
    
    remoteSchema = property(__remoteSchema.value, __remoteSchema.set, None, '')

    
    # Attribute nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'nilReason'), 'nilReason', '__httpwww_opengis_netgml3_2_TemporalDatumPropertyType_nilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 51, 2)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 51, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}type uses Python identifier type
    __type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'type'), 'type', '__httpwww_opengis_netgml3_2_TemporalDatumPropertyType_httpwww_w3_org1999xlinktype', _ImportedBinding_bindings_v1411_write__xlink.typeType, fixed=True, unicode_default='simple')
    __type._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 29, 1)
    __type._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 112, 2)
    
    type = property(__type.value, __type.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}href uses Python identifier href
    __href = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'href'), 'href', '__httpwww_opengis_netgml3_2_TemporalDatumPropertyType_httpwww_w3_org1999xlinkhref', _ImportedBinding_bindings_v1411_write__xlink.hrefType)
    __href._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 42, 1)
    __href._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 113, 2)
    
    href = property(__href.value, __href.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}role uses Python identifier role
    __role = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'role'), 'role', '__httpwww_opengis_netgml3_2_TemporalDatumPropertyType_httpwww_w3_org1999xlinkrole', _ImportedBinding_bindings_v1411_write__xlink.roleType)
    __role._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 48, 1)
    __role._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 114, 2)
    
    role = property(__role.value, __role.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}arcrole uses Python identifier arcrole
    __arcrole = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'arcrole'), 'arcrole', '__httpwww_opengis_netgml3_2_TemporalDatumPropertyType_httpwww_w3_org1999xlinkarcrole', _ImportedBinding_bindings_v1411_write__xlink.arcroleType)
    __arcrole._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 56, 1)
    __arcrole._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 115, 2)
    
    arcrole = property(__arcrole.value, __arcrole.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}title uses Python identifier title
    __title = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'title'), 'title', '__httpwww_opengis_netgml3_2_TemporalDatumPropertyType_httpwww_w3_org1999xlinktitle', _ImportedBinding_bindings_v1411_write__xlink.titleAttrType)
    __title._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 64, 1)
    __title._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 116, 2)
    
    title = property(__title.value, __title.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}show uses Python identifier show
    __show = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'show'), 'show', '__httpwww_opengis_netgml3_2_TemporalDatumPropertyType_httpwww_w3_org1999xlinkshow', _ImportedBinding_bindings_v1411_write__xlink.showType)
    __show._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 70, 1)
    __show._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 117, 2)
    
    show = property(__show.value, __show.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}actuate uses Python identifier actuate
    __actuate = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'actuate'), 'actuate', '__httpwww_opengis_netgml3_2_TemporalDatumPropertyType_httpwww_w3_org1999xlinkactuate', _ImportedBinding_bindings_v1411_write__xlink.actuateType)
    __actuate._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 82, 1)
    __actuate._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 118, 2)
    
    actuate = property(__actuate.value, __actuate.set, None, None)

    _ElementMap.update({
        __TemporalDatum.name() : __TemporalDatum
    })
    _AttributeMap.update({
        __remoteSchema.name() : __remoteSchema,
        __nilReason.name() : __nilReason,
        __type.name() : __type,
        __href.name() : __href,
        __role.name() : __role,
        __arcrole.name() : __arcrole,
        __title.name() : __title,
        __show.name() : __show,
        __actuate.name() : __actuate
    })
_module_typeBindings.TemporalDatumPropertyType = TemporalDatumPropertyType
_Namespace_gml.addCategoryObject('typeBinding', 'TemporalDatumPropertyType', TemporalDatumPropertyType)


# Complex type {http://www.opengis.net/gml/3.2}OperationPropertyType with content type ELEMENT_ONLY
class OperationPropertyType (pyxb.binding.basis.complexTypeDefinition):
    """"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'OperationPropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 88, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.opengis.net/gml/3.2}AbstractOperation uses Python identifier AbstractOperation
    __AbstractOperation = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractOperation'), 'AbstractOperation', '__httpwww_opengis_netgml3_2_OperationPropertyType_httpwww_opengis_netgml3_2AbstractOperation', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 83, 1), )

    
    AbstractOperation = property(__AbstractOperation.value, __AbstractOperation.set, None, '')

    
    # Attribute {http://www.opengis.net/gml/3.2}remoteSchema uses Python identifier remoteSchema
    __remoteSchema = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gml, 'remoteSchema'), 'remoteSchema', '__httpwww_opengis_netgml3_2_OperationPropertyType_httpwww_opengis_netgml3_2remoteSchema', pyxb.binding.datatypes.anyURI)
    __remoteSchema._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 638, 1)
    __remoteSchema._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 52, 2)
    
    remoteSchema = property(__remoteSchema.value, __remoteSchema.set, None, '')

    
    # Attribute nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'nilReason'), 'nilReason', '__httpwww_opengis_netgml3_2_OperationPropertyType_nilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 51, 2)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 51, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}type uses Python identifier type
    __type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'type'), 'type', '__httpwww_opengis_netgml3_2_OperationPropertyType_httpwww_w3_org1999xlinktype', _ImportedBinding_bindings_v1411_write__xlink.typeType, fixed=True, unicode_default='simple')
    __type._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 29, 1)
    __type._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 112, 2)
    
    type = property(__type.value, __type.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}href uses Python identifier href
    __href = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'href'), 'href', '__httpwww_opengis_netgml3_2_OperationPropertyType_httpwww_w3_org1999xlinkhref', _ImportedBinding_bindings_v1411_write__xlink.hrefType)
    __href._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 42, 1)
    __href._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 113, 2)
    
    href = property(__href.value, __href.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}role uses Python identifier role
    __role = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'role'), 'role', '__httpwww_opengis_netgml3_2_OperationPropertyType_httpwww_w3_org1999xlinkrole', _ImportedBinding_bindings_v1411_write__xlink.roleType)
    __role._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 48, 1)
    __role._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 114, 2)
    
    role = property(__role.value, __role.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}arcrole uses Python identifier arcrole
    __arcrole = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'arcrole'), 'arcrole', '__httpwww_opengis_netgml3_2_OperationPropertyType_httpwww_w3_org1999xlinkarcrole', _ImportedBinding_bindings_v1411_write__xlink.arcroleType)
    __arcrole._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 56, 1)
    __arcrole._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 115, 2)
    
    arcrole = property(__arcrole.value, __arcrole.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}title uses Python identifier title
    __title = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'title'), 'title', '__httpwww_opengis_netgml3_2_OperationPropertyType_httpwww_w3_org1999xlinktitle', _ImportedBinding_bindings_v1411_write__xlink.titleAttrType)
    __title._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 64, 1)
    __title._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 116, 2)
    
    title = property(__title.value, __title.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}show uses Python identifier show
    __show = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'show'), 'show', '__httpwww_opengis_netgml3_2_OperationPropertyType_httpwww_w3_org1999xlinkshow', _ImportedBinding_bindings_v1411_write__xlink.showType)
    __show._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 70, 1)
    __show._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 117, 2)
    
    show = property(__show.value, __show.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}actuate uses Python identifier actuate
    __actuate = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'actuate'), 'actuate', '__httpwww_opengis_netgml3_2_OperationPropertyType_httpwww_w3_org1999xlinkactuate', _ImportedBinding_bindings_v1411_write__xlink.actuateType)
    __actuate._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 82, 1)
    __actuate._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 118, 2)
    
    actuate = property(__actuate.value, __actuate.set, None, None)

    _ElementMap.update({
        __AbstractOperation.name() : __AbstractOperation
    })
    _AttributeMap.update({
        __remoteSchema.name() : __remoteSchema,
        __nilReason.name() : __nilReason,
        __type.name() : __type,
        __href.name() : __href,
        __role.name() : __role,
        __arcrole.name() : __arcrole,
        __title.name() : __title,
        __show.name() : __show,
        __actuate.name() : __actuate
    })
_module_typeBindings.OperationPropertyType = OperationPropertyType
_Namespace_gml.addCategoryObject('typeBinding', 'OperationPropertyType', OperationPropertyType)


# Complex type {http://www.opengis.net/gml/3.2}TemporalCSPropertyType with content type ELEMENT_ONLY
class TemporalCSPropertyType (pyxb.binding.basis.complexTypeDefinition):
    """"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'TemporalCSPropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 260, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.opengis.net/gml/3.2}TemporalCS uses Python identifier TemporalCS
    __TemporalCS = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'TemporalCS'), 'TemporalCS', '__httpwww_opengis_netgml3_2_TemporalCSPropertyType_httpwww_opengis_netgml3_2TemporalCS', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 247, 1), )

    
    TemporalCS = property(__TemporalCS.value, __TemporalCS.set, None, '')

    
    # Attribute {http://www.opengis.net/gml/3.2}remoteSchema uses Python identifier remoteSchema
    __remoteSchema = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gml, 'remoteSchema'), 'remoteSchema', '__httpwww_opengis_netgml3_2_TemporalCSPropertyType_httpwww_opengis_netgml3_2remoteSchema', pyxb.binding.datatypes.anyURI)
    __remoteSchema._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 638, 1)
    __remoteSchema._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 52, 2)
    
    remoteSchema = property(__remoteSchema.value, __remoteSchema.set, None, '')

    
    # Attribute nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'nilReason'), 'nilReason', '__httpwww_opengis_netgml3_2_TemporalCSPropertyType_nilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 51, 2)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 51, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}type uses Python identifier type
    __type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'type'), 'type', '__httpwww_opengis_netgml3_2_TemporalCSPropertyType_httpwww_w3_org1999xlinktype', _ImportedBinding_bindings_v1411_write__xlink.typeType, fixed=True, unicode_default='simple')
    __type._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 29, 1)
    __type._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 112, 2)
    
    type = property(__type.value, __type.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}href uses Python identifier href
    __href = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'href'), 'href', '__httpwww_opengis_netgml3_2_TemporalCSPropertyType_httpwww_w3_org1999xlinkhref', _ImportedBinding_bindings_v1411_write__xlink.hrefType)
    __href._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 42, 1)
    __href._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 113, 2)
    
    href = property(__href.value, __href.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}role uses Python identifier role
    __role = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'role'), 'role', '__httpwww_opengis_netgml3_2_TemporalCSPropertyType_httpwww_w3_org1999xlinkrole', _ImportedBinding_bindings_v1411_write__xlink.roleType)
    __role._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 48, 1)
    __role._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 114, 2)
    
    role = property(__role.value, __role.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}arcrole uses Python identifier arcrole
    __arcrole = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'arcrole'), 'arcrole', '__httpwww_opengis_netgml3_2_TemporalCSPropertyType_httpwww_w3_org1999xlinkarcrole', _ImportedBinding_bindings_v1411_write__xlink.arcroleType)
    __arcrole._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 56, 1)
    __arcrole._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 115, 2)
    
    arcrole = property(__arcrole.value, __arcrole.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}title uses Python identifier title
    __title = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'title'), 'title', '__httpwww_opengis_netgml3_2_TemporalCSPropertyType_httpwww_w3_org1999xlinktitle', _ImportedBinding_bindings_v1411_write__xlink.titleAttrType)
    __title._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 64, 1)
    __title._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 116, 2)
    
    title = property(__title.value, __title.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}show uses Python identifier show
    __show = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'show'), 'show', '__httpwww_opengis_netgml3_2_TemporalCSPropertyType_httpwww_w3_org1999xlinkshow', _ImportedBinding_bindings_v1411_write__xlink.showType)
    __show._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 70, 1)
    __show._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 117, 2)
    
    show = property(__show.value, __show.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}actuate uses Python identifier actuate
    __actuate = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'actuate'), 'actuate', '__httpwww_opengis_netgml3_2_TemporalCSPropertyType_httpwww_w3_org1999xlinkactuate', _ImportedBinding_bindings_v1411_write__xlink.actuateType)
    __actuate._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 82, 1)
    __actuate._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 118, 2)
    
    actuate = property(__actuate.value, __actuate.set, None, None)

    _ElementMap.update({
        __TemporalCS.name() : __TemporalCS
    })
    _AttributeMap.update({
        __remoteSchema.name() : __remoteSchema,
        __nilReason.name() : __nilReason,
        __type.name() : __type,
        __href.name() : __href,
        __role.name() : __role,
        __arcrole.name() : __arcrole,
        __title.name() : __title,
        __show.name() : __show,
        __actuate.name() : __actuate
    })
_module_typeBindings.TemporalCSPropertyType = TemporalCSPropertyType
_Namespace_gml.addCategoryObject('typeBinding', 'TemporalCSPropertyType', TemporalCSPropertyType)


# Complex type {http://www.opengis.net/gml/3.2}ObliqueCartesianCSPropertyType with content type ELEMENT_ONLY
class ObliqueCartesianCSPropertyType (pyxb.binding.basis.complexTypeDefinition):
    """"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'ObliqueCartesianCSPropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 312, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.opengis.net/gml/3.2}ObliqueCartesianCS uses Python identifier ObliqueCartesianCS
    __ObliqueCartesianCS = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'ObliqueCartesianCS'), 'ObliqueCartesianCS', '__httpwww_opengis_netgml3_2_ObliqueCartesianCSPropertyType_httpwww_opengis_netgml3_2ObliqueCartesianCS', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 299, 1), )

    
    ObliqueCartesianCS = property(__ObliqueCartesianCS.value, __ObliqueCartesianCS.set, None, '')

    
    # Attribute {http://www.opengis.net/gml/3.2}remoteSchema uses Python identifier remoteSchema
    __remoteSchema = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gml, 'remoteSchema'), 'remoteSchema', '__httpwww_opengis_netgml3_2_ObliqueCartesianCSPropertyType_httpwww_opengis_netgml3_2remoteSchema', pyxb.binding.datatypes.anyURI)
    __remoteSchema._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 638, 1)
    __remoteSchema._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 52, 2)
    
    remoteSchema = property(__remoteSchema.value, __remoteSchema.set, None, '')

    
    # Attribute nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'nilReason'), 'nilReason', '__httpwww_opengis_netgml3_2_ObliqueCartesianCSPropertyType_nilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 51, 2)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 51, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}type uses Python identifier type
    __type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'type'), 'type', '__httpwww_opengis_netgml3_2_ObliqueCartesianCSPropertyType_httpwww_w3_org1999xlinktype', _ImportedBinding_bindings_v1411_write__xlink.typeType, fixed=True, unicode_default='simple')
    __type._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 29, 1)
    __type._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 112, 2)
    
    type = property(__type.value, __type.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}href uses Python identifier href
    __href = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'href'), 'href', '__httpwww_opengis_netgml3_2_ObliqueCartesianCSPropertyType_httpwww_w3_org1999xlinkhref', _ImportedBinding_bindings_v1411_write__xlink.hrefType)
    __href._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 42, 1)
    __href._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 113, 2)
    
    href = property(__href.value, __href.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}role uses Python identifier role
    __role = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'role'), 'role', '__httpwww_opengis_netgml3_2_ObliqueCartesianCSPropertyType_httpwww_w3_org1999xlinkrole', _ImportedBinding_bindings_v1411_write__xlink.roleType)
    __role._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 48, 1)
    __role._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 114, 2)
    
    role = property(__role.value, __role.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}arcrole uses Python identifier arcrole
    __arcrole = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'arcrole'), 'arcrole', '__httpwww_opengis_netgml3_2_ObliqueCartesianCSPropertyType_httpwww_w3_org1999xlinkarcrole', _ImportedBinding_bindings_v1411_write__xlink.arcroleType)
    __arcrole._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 56, 1)
    __arcrole._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 115, 2)
    
    arcrole = property(__arcrole.value, __arcrole.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}title uses Python identifier title
    __title = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'title'), 'title', '__httpwww_opengis_netgml3_2_ObliqueCartesianCSPropertyType_httpwww_w3_org1999xlinktitle', _ImportedBinding_bindings_v1411_write__xlink.titleAttrType)
    __title._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 64, 1)
    __title._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 116, 2)
    
    title = property(__title.value, __title.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}show uses Python identifier show
    __show = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'show'), 'show', '__httpwww_opengis_netgml3_2_ObliqueCartesianCSPropertyType_httpwww_w3_org1999xlinkshow', _ImportedBinding_bindings_v1411_write__xlink.showType)
    __show._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 70, 1)
    __show._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 117, 2)
    
    show = property(__show.value, __show.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}actuate uses Python identifier actuate
    __actuate = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'actuate'), 'actuate', '__httpwww_opengis_netgml3_2_ObliqueCartesianCSPropertyType_httpwww_w3_org1999xlinkactuate', _ImportedBinding_bindings_v1411_write__xlink.actuateType)
    __actuate._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 82, 1)
    __actuate._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 118, 2)
    
    actuate = property(__actuate.value, __actuate.set, None, None)

    _ElementMap.update({
        __ObliqueCartesianCS.name() : __ObliqueCartesianCS
    })
    _AttributeMap.update({
        __remoteSchema.name() : __remoteSchema,
        __nilReason.name() : __nilReason,
        __type.name() : __type,
        __href.name() : __href,
        __role.name() : __role,
        __arcrole.name() : __arcrole,
        __title.name() : __title,
        __show.name() : __show,
        __actuate.name() : __actuate
    })
_module_typeBindings.ObliqueCartesianCSPropertyType = ObliqueCartesianCSPropertyType
_Namespace_gml.addCategoryObject('typeBinding', 'ObliqueCartesianCSPropertyType', ObliqueCartesianCSPropertyType)


# Complex type {http://www.opengis.net/gml/3.2}GeographicCRSPropertyType with content type ELEMENT_ONLY
class GeographicCRSPropertyType (pyxb.binding.basis.complexTypeDefinition):
    """"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'GeographicCRSPropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 469, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.opengis.net/gml/3.2}GeographicCRS uses Python identifier GeographicCRS
    __GeographicCRS = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'GeographicCRS'), 'GeographicCRS', '__httpwww_opengis_netgml3_2_GeographicCRSPropertyType_httpwww_opengis_netgml3_2GeographicCRS', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 451, 1), )

    
    GeographicCRS = property(__GeographicCRS.value, __GeographicCRS.set, None, '')

    
    # Attribute {http://www.opengis.net/gml/3.2}remoteSchema uses Python identifier remoteSchema
    __remoteSchema = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gml, 'remoteSchema'), 'remoteSchema', '__httpwww_opengis_netgml3_2_GeographicCRSPropertyType_httpwww_opengis_netgml3_2remoteSchema', pyxb.binding.datatypes.anyURI)
    __remoteSchema._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 638, 1)
    __remoteSchema._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 52, 2)
    
    remoteSchema = property(__remoteSchema.value, __remoteSchema.set, None, '')

    
    # Attribute nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'nilReason'), 'nilReason', '__httpwww_opengis_netgml3_2_GeographicCRSPropertyType_nilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 51, 2)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 51, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}type uses Python identifier type
    __type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'type'), 'type', '__httpwww_opengis_netgml3_2_GeographicCRSPropertyType_httpwww_w3_org1999xlinktype', _ImportedBinding_bindings_v1411_write__xlink.typeType, fixed=True, unicode_default='simple')
    __type._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 29, 1)
    __type._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 112, 2)
    
    type = property(__type.value, __type.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}href uses Python identifier href
    __href = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'href'), 'href', '__httpwww_opengis_netgml3_2_GeographicCRSPropertyType_httpwww_w3_org1999xlinkhref', _ImportedBinding_bindings_v1411_write__xlink.hrefType)
    __href._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 42, 1)
    __href._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 113, 2)
    
    href = property(__href.value, __href.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}role uses Python identifier role
    __role = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'role'), 'role', '__httpwww_opengis_netgml3_2_GeographicCRSPropertyType_httpwww_w3_org1999xlinkrole', _ImportedBinding_bindings_v1411_write__xlink.roleType)
    __role._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 48, 1)
    __role._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 114, 2)
    
    role = property(__role.value, __role.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}arcrole uses Python identifier arcrole
    __arcrole = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'arcrole'), 'arcrole', '__httpwww_opengis_netgml3_2_GeographicCRSPropertyType_httpwww_w3_org1999xlinkarcrole', _ImportedBinding_bindings_v1411_write__xlink.arcroleType)
    __arcrole._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 56, 1)
    __arcrole._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 115, 2)
    
    arcrole = property(__arcrole.value, __arcrole.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}title uses Python identifier title
    __title = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'title'), 'title', '__httpwww_opengis_netgml3_2_GeographicCRSPropertyType_httpwww_w3_org1999xlinktitle', _ImportedBinding_bindings_v1411_write__xlink.titleAttrType)
    __title._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 64, 1)
    __title._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 116, 2)
    
    title = property(__title.value, __title.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}show uses Python identifier show
    __show = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'show'), 'show', '__httpwww_opengis_netgml3_2_GeographicCRSPropertyType_httpwww_w3_org1999xlinkshow', _ImportedBinding_bindings_v1411_write__xlink.showType)
    __show._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 70, 1)
    __show._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 117, 2)
    
    show = property(__show.value, __show.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}actuate uses Python identifier actuate
    __actuate = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'actuate'), 'actuate', '__httpwww_opengis_netgml3_2_GeographicCRSPropertyType_httpwww_w3_org1999xlinkactuate', _ImportedBinding_bindings_v1411_write__xlink.actuateType)
    __actuate._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 82, 1)
    __actuate._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 118, 2)
    
    actuate = property(__actuate.value, __actuate.set, None, None)

    _ElementMap.update({
        __GeographicCRS.name() : __GeographicCRS
    })
    _AttributeMap.update({
        __remoteSchema.name() : __remoteSchema,
        __nilReason.name() : __nilReason,
        __type.name() : __type,
        __href.name() : __href,
        __role.name() : __role,
        __arcrole.name() : __arcrole,
        __title.name() : __title,
        __show.name() : __show,
        __actuate.name() : __actuate
    })
_module_typeBindings.GeographicCRSPropertyType = GeographicCRSPropertyType
_Namespace_gml.addCategoryObject('typeBinding', 'GeographicCRSPropertyType', GeographicCRSPropertyType)


# Complex type {http://www.opengis.net/gml/3.2}GeocentricCRSPropertyType with content type ELEMENT_ONLY
class GeocentricCRSPropertyType (pyxb.binding.basis.complexTypeDefinition):
    """"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'GeocentricCRSPropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 504, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.opengis.net/gml/3.2}GeocentricCRS uses Python identifier GeocentricCRS
    __GeocentricCRS = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'GeocentricCRS'), 'GeocentricCRS', '__httpwww_opengis_netgml3_2_GeocentricCRSPropertyType_httpwww_opengis_netgml3_2GeocentricCRS', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 483, 1), )

    
    GeocentricCRS = property(__GeocentricCRS.value, __GeocentricCRS.set, None, '')

    
    # Attribute {http://www.opengis.net/gml/3.2}remoteSchema uses Python identifier remoteSchema
    __remoteSchema = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gml, 'remoteSchema'), 'remoteSchema', '__httpwww_opengis_netgml3_2_GeocentricCRSPropertyType_httpwww_opengis_netgml3_2remoteSchema', pyxb.binding.datatypes.anyURI)
    __remoteSchema._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 638, 1)
    __remoteSchema._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 52, 2)
    
    remoteSchema = property(__remoteSchema.value, __remoteSchema.set, None, '')

    
    # Attribute nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'nilReason'), 'nilReason', '__httpwww_opengis_netgml3_2_GeocentricCRSPropertyType_nilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 51, 2)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 51, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}type uses Python identifier type
    __type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'type'), 'type', '__httpwww_opengis_netgml3_2_GeocentricCRSPropertyType_httpwww_w3_org1999xlinktype', _ImportedBinding_bindings_v1411_write__xlink.typeType, fixed=True, unicode_default='simple')
    __type._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 29, 1)
    __type._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 112, 2)
    
    type = property(__type.value, __type.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}href uses Python identifier href
    __href = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'href'), 'href', '__httpwww_opengis_netgml3_2_GeocentricCRSPropertyType_httpwww_w3_org1999xlinkhref', _ImportedBinding_bindings_v1411_write__xlink.hrefType)
    __href._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 42, 1)
    __href._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 113, 2)
    
    href = property(__href.value, __href.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}role uses Python identifier role
    __role = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'role'), 'role', '__httpwww_opengis_netgml3_2_GeocentricCRSPropertyType_httpwww_w3_org1999xlinkrole', _ImportedBinding_bindings_v1411_write__xlink.roleType)
    __role._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 48, 1)
    __role._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 114, 2)
    
    role = property(__role.value, __role.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}arcrole uses Python identifier arcrole
    __arcrole = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'arcrole'), 'arcrole', '__httpwww_opengis_netgml3_2_GeocentricCRSPropertyType_httpwww_w3_org1999xlinkarcrole', _ImportedBinding_bindings_v1411_write__xlink.arcroleType)
    __arcrole._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 56, 1)
    __arcrole._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 115, 2)
    
    arcrole = property(__arcrole.value, __arcrole.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}title uses Python identifier title
    __title = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'title'), 'title', '__httpwww_opengis_netgml3_2_GeocentricCRSPropertyType_httpwww_w3_org1999xlinktitle', _ImportedBinding_bindings_v1411_write__xlink.titleAttrType)
    __title._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 64, 1)
    __title._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 116, 2)
    
    title = property(__title.value, __title.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}show uses Python identifier show
    __show = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'show'), 'show', '__httpwww_opengis_netgml3_2_GeocentricCRSPropertyType_httpwww_w3_org1999xlinkshow', _ImportedBinding_bindings_v1411_write__xlink.showType)
    __show._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 70, 1)
    __show._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 117, 2)
    
    show = property(__show.value, __show.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}actuate uses Python identifier actuate
    __actuate = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'actuate'), 'actuate', '__httpwww_opengis_netgml3_2_GeocentricCRSPropertyType_httpwww_w3_org1999xlinkactuate', _ImportedBinding_bindings_v1411_write__xlink.actuateType)
    __actuate._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 82, 1)
    __actuate._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 118, 2)
    
    actuate = property(__actuate.value, __actuate.set, None, None)

    _ElementMap.update({
        __GeocentricCRS.name() : __GeocentricCRS
    })
    _AttributeMap.update({
        __remoteSchema.name() : __remoteSchema,
        __nilReason.name() : __nilReason,
        __type.name() : __type,
        __href.name() : __href,
        __role.name() : __role,
        __arcrole.name() : __arcrole,
        __title.name() : __title,
        __show.name() : __show,
        __actuate.name() : __actuate
    })
_module_typeBindings.GeocentricCRSPropertyType = GeocentricCRSPropertyType
_Namespace_gml.addCategoryObject('typeBinding', 'GeocentricCRSPropertyType', GeocentricCRSPropertyType)


# Complex type {http://www.opengis.net/gml/3.2}StringOrRefType with content type SIMPLE
class StringOrRefType (pyxb.binding.basis.complexTypeDefinition):
    """"""
    _TypeDefinition = pyxb.binding.datatypes.string
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_SIMPLE
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'StringOrRefType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 662, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.string
    
    # Attribute {http://www.opengis.net/gml/3.2}remoteSchema uses Python identifier remoteSchema
    __remoteSchema = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gml, 'remoteSchema'), 'remoteSchema', '__httpwww_opengis_netgml3_2_StringOrRefType_httpwww_opengis_netgml3_2remoteSchema', pyxb.binding.datatypes.anyURI)
    __remoteSchema._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 638, 1)
    __remoteSchema._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 52, 2)
    
    remoteSchema = property(__remoteSchema.value, __remoteSchema.set, None, '')

    
    # Attribute nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'nilReason'), 'nilReason', '__httpwww_opengis_netgml3_2_StringOrRefType_nilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 51, 2)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 51, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}type uses Python identifier type
    __type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'type'), 'type', '__httpwww_opengis_netgml3_2_StringOrRefType_httpwww_w3_org1999xlinktype', _ImportedBinding_bindings_v1411_write__xlink.typeType, fixed=True, unicode_default='simple')
    __type._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 29, 1)
    __type._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 112, 2)
    
    type = property(__type.value, __type.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}href uses Python identifier href
    __href = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'href'), 'href', '__httpwww_opengis_netgml3_2_StringOrRefType_httpwww_w3_org1999xlinkhref', _ImportedBinding_bindings_v1411_write__xlink.hrefType)
    __href._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 42, 1)
    __href._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 113, 2)
    
    href = property(__href.value, __href.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}role uses Python identifier role
    __role = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'role'), 'role', '__httpwww_opengis_netgml3_2_StringOrRefType_httpwww_w3_org1999xlinkrole', _ImportedBinding_bindings_v1411_write__xlink.roleType)
    __role._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 48, 1)
    __role._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 114, 2)
    
    role = property(__role.value, __role.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}arcrole uses Python identifier arcrole
    __arcrole = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'arcrole'), 'arcrole', '__httpwww_opengis_netgml3_2_StringOrRefType_httpwww_w3_org1999xlinkarcrole', _ImportedBinding_bindings_v1411_write__xlink.arcroleType)
    __arcrole._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 56, 1)
    __arcrole._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 115, 2)
    
    arcrole = property(__arcrole.value, __arcrole.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}title uses Python identifier title
    __title = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'title'), 'title', '__httpwww_opengis_netgml3_2_StringOrRefType_httpwww_w3_org1999xlinktitle', _ImportedBinding_bindings_v1411_write__xlink.titleAttrType)
    __title._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 64, 1)
    __title._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 116, 2)
    
    title = property(__title.value, __title.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}show uses Python identifier show
    __show = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'show'), 'show', '__httpwww_opengis_netgml3_2_StringOrRefType_httpwww_w3_org1999xlinkshow', _ImportedBinding_bindings_v1411_write__xlink.showType)
    __show._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 70, 1)
    __show._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 117, 2)
    
    show = property(__show.value, __show.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}actuate uses Python identifier actuate
    __actuate = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'actuate'), 'actuate', '__httpwww_opengis_netgml3_2_StringOrRefType_httpwww_w3_org1999xlinkactuate', _ImportedBinding_bindings_v1411_write__xlink.actuateType)
    __actuate._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 82, 1)
    __actuate._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 118, 2)
    
    actuate = property(__actuate.value, __actuate.set, None, None)

    _ElementMap.update({
        
    })
    _AttributeMap.update({
        __remoteSchema.name() : __remoteSchema,
        __nilReason.name() : __nilReason,
        __type.name() : __type,
        __href.name() : __href,
        __role.name() : __role,
        __arcrole.name() : __arcrole,
        __title.name() : __title,
        __show.name() : __show,
        __actuate.name() : __actuate
    })
_module_typeBindings.StringOrRefType = StringOrRefType
_Namespace_gml.addCategoryObject('typeBinding', 'StringOrRefType', StringOrRefType)


# Complex type {http://www.opengis.net/gml/3.2}MetaDataPropertyType with content type ELEMENT_ONLY
class MetaDataPropertyType (pyxb.binding.basis.complexTypeDefinition):
    """"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'MetaDataPropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 712, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.opengis.net/gml/3.2}AbstractMetaData uses Python identifier AbstractMetaData
    __AbstractMetaData = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractMetaData'), 'AbstractMetaData', '__httpwww_opengis_netgml3_2_MetaDataPropertyType_httpwww_opengis_netgml3_2AbstractMetaData', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 722, 1), )

    
    AbstractMetaData = property(__AbstractMetaData.value, __AbstractMetaData.set, None, '')

    
    # Attribute {http://www.opengis.net/gml/3.2}remoteSchema uses Python identifier remoteSchema
    __remoteSchema = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gml, 'remoteSchema'), 'remoteSchema', '__httpwww_opengis_netgml3_2_MetaDataPropertyType_httpwww_opengis_netgml3_2remoteSchema', pyxb.binding.datatypes.anyURI)
    __remoteSchema._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 638, 1)
    __remoteSchema._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 52, 2)
    
    remoteSchema = property(__remoteSchema.value, __remoteSchema.set, None, '')

    
    # Attribute about uses Python identifier about
    __about = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'about'), 'about', '__httpwww_opengis_netgml3_2_MetaDataPropertyType_about', pyxb.binding.datatypes.anyURI)
    __about._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 720, 2)
    __about._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 720, 2)
    
    about = property(__about.value, __about.set, None, None)

    
    # Attribute nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'nilReason'), 'nilReason', '__httpwww_opengis_netgml3_2_MetaDataPropertyType_nilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 51, 2)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 51, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}type uses Python identifier type
    __type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'type'), 'type', '__httpwww_opengis_netgml3_2_MetaDataPropertyType_httpwww_w3_org1999xlinktype', _ImportedBinding_bindings_v1411_write__xlink.typeType, fixed=True, unicode_default='simple')
    __type._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 29, 1)
    __type._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 112, 2)
    
    type = property(__type.value, __type.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}href uses Python identifier href
    __href = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'href'), 'href', '__httpwww_opengis_netgml3_2_MetaDataPropertyType_httpwww_w3_org1999xlinkhref', _ImportedBinding_bindings_v1411_write__xlink.hrefType)
    __href._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 42, 1)
    __href._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 113, 2)
    
    href = property(__href.value, __href.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}role uses Python identifier role
    __role = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'role'), 'role', '__httpwww_opengis_netgml3_2_MetaDataPropertyType_httpwww_w3_org1999xlinkrole', _ImportedBinding_bindings_v1411_write__xlink.roleType)
    __role._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 48, 1)
    __role._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 114, 2)
    
    role = property(__role.value, __role.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}arcrole uses Python identifier arcrole
    __arcrole = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'arcrole'), 'arcrole', '__httpwww_opengis_netgml3_2_MetaDataPropertyType_httpwww_w3_org1999xlinkarcrole', _ImportedBinding_bindings_v1411_write__xlink.arcroleType)
    __arcrole._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 56, 1)
    __arcrole._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 115, 2)
    
    arcrole = property(__arcrole.value, __arcrole.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}title uses Python identifier title
    __title = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'title'), 'title', '__httpwww_opengis_netgml3_2_MetaDataPropertyType_httpwww_w3_org1999xlinktitle', _ImportedBinding_bindings_v1411_write__xlink.titleAttrType)
    __title._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 64, 1)
    __title._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 116, 2)
    
    title = property(__title.value, __title.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}show uses Python identifier show
    __show = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'show'), 'show', '__httpwww_opengis_netgml3_2_MetaDataPropertyType_httpwww_w3_org1999xlinkshow', _ImportedBinding_bindings_v1411_write__xlink.showType)
    __show._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 70, 1)
    __show._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 117, 2)
    
    show = property(__show.value, __show.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}actuate uses Python identifier actuate
    __actuate = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'actuate'), 'actuate', '__httpwww_opengis_netgml3_2_MetaDataPropertyType_httpwww_w3_org1999xlinkactuate', _ImportedBinding_bindings_v1411_write__xlink.actuateType)
    __actuate._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 82, 1)
    __actuate._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 118, 2)
    
    actuate = property(__actuate.value, __actuate.set, None, None)

    _ElementMap.update({
        __AbstractMetaData.name() : __AbstractMetaData
    })
    _AttributeMap.update({
        __remoteSchema.name() : __remoteSchema,
        __about.name() : __about,
        __nilReason.name() : __nilReason,
        __type.name() : __type,
        __href.name() : __href,
        __role.name() : __role,
        __arcrole.name() : __arcrole,
        __title.name() : __title,
        __show.name() : __show,
        __actuate.name() : __actuate
    })
_module_typeBindings.MetaDataPropertyType = MetaDataPropertyType
_Namespace_gml.addCategoryObject('typeBinding', 'MetaDataPropertyType', MetaDataPropertyType)


# Complex type {http://www.opengis.net/gml/3.2}LocationPropertyType with content type ELEMENT_ONLY
class LocationPropertyType (pyxb.binding.basis.complexTypeDefinition):
    """"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'LocationPropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 766, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.opengis.net/gml/3.2}Null uses Python identifier Null
    __Null = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'Null'), 'Null', '__httpwww_opengis_netgml3_2_LocationPropertyType_httpwww_opengis_netgml3_2Null', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 13, 1), )

    
    Null = property(__Null.value, __Null.set, None, '')

    
    # Element {http://www.opengis.net/gml/3.2}LocationString uses Python identifier LocationString
    __LocationString = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'LocationString'), 'LocationString', '__httpwww_opengis_netgml3_2_LocationPropertyType_httpwww_opengis_netgml3_2LocationString', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 780, 1), )

    
    LocationString = property(__LocationString.value, __LocationString.set, None, '')

    
    # Element {http://www.opengis.net/gml/3.2}LocationKeyWord uses Python identifier LocationKeyWord
    __LocationKeyWord = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'LocationKeyWord'), 'LocationKeyWord', '__httpwww_opengis_netgml3_2_LocationPropertyType_httpwww_opengis_netgml3_2LocationKeyWord', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 785, 1), )

    
    LocationKeyWord = property(__LocationKeyWord.value, __LocationKeyWord.set, None, '')

    
    # Element {http://www.opengis.net/gml/3.2}AbstractGeometry uses Python identifier AbstractGeometry
    __AbstractGeometry = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractGeometry'), 'AbstractGeometry', '__httpwww_opengis_netgml3_2_LocationPropertyType_httpwww_opengis_netgml3_2AbstractGeometry', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic0d1d.xsd', 50, 1), )

    
    AbstractGeometry = property(__AbstractGeometry.value, __AbstractGeometry.set, None, 'The AbstractGeometry element is the abstract head of the substitution group for all geometry elements of GML. This includes pre-defined and user-defined geometry elements. Any geometry element shall be a direct or indirect extension/restriction of AbstractGeometryType and shall be directly or indirectly in the substitution group of AbstractGeometry.')

    
    # Attribute {http://www.opengis.net/gml/3.2}remoteSchema uses Python identifier remoteSchema
    __remoteSchema = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gml, 'remoteSchema'), 'remoteSchema', '__httpwww_opengis_netgml3_2_LocationPropertyType_httpwww_opengis_netgml3_2remoteSchema', pyxb.binding.datatypes.anyURI)
    __remoteSchema._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 638, 1)
    __remoteSchema._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 52, 2)
    
    remoteSchema = property(__remoteSchema.value, __remoteSchema.set, None, '')

    
    # Attribute nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'nilReason'), 'nilReason', '__httpwww_opengis_netgml3_2_LocationPropertyType_nilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 51, 2)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 51, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}type uses Python identifier type
    __type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'type'), 'type', '__httpwww_opengis_netgml3_2_LocationPropertyType_httpwww_w3_org1999xlinktype', _ImportedBinding_bindings_v1411_write__xlink.typeType, fixed=True, unicode_default='simple')
    __type._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 29, 1)
    __type._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 112, 2)
    
    type = property(__type.value, __type.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}href uses Python identifier href
    __href = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'href'), 'href', '__httpwww_opengis_netgml3_2_LocationPropertyType_httpwww_w3_org1999xlinkhref', _ImportedBinding_bindings_v1411_write__xlink.hrefType)
    __href._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 42, 1)
    __href._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 113, 2)
    
    href = property(__href.value, __href.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}role uses Python identifier role
    __role = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'role'), 'role', '__httpwww_opengis_netgml3_2_LocationPropertyType_httpwww_w3_org1999xlinkrole', _ImportedBinding_bindings_v1411_write__xlink.roleType)
    __role._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 48, 1)
    __role._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 114, 2)
    
    role = property(__role.value, __role.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}arcrole uses Python identifier arcrole
    __arcrole = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'arcrole'), 'arcrole', '__httpwww_opengis_netgml3_2_LocationPropertyType_httpwww_w3_org1999xlinkarcrole', _ImportedBinding_bindings_v1411_write__xlink.arcroleType)
    __arcrole._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 56, 1)
    __arcrole._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 115, 2)
    
    arcrole = property(__arcrole.value, __arcrole.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}title uses Python identifier title
    __title = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'title'), 'title', '__httpwww_opengis_netgml3_2_LocationPropertyType_httpwww_w3_org1999xlinktitle', _ImportedBinding_bindings_v1411_write__xlink.titleAttrType)
    __title._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 64, 1)
    __title._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 116, 2)
    
    title = property(__title.value, __title.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}show uses Python identifier show
    __show = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'show'), 'show', '__httpwww_opengis_netgml3_2_LocationPropertyType_httpwww_w3_org1999xlinkshow', _ImportedBinding_bindings_v1411_write__xlink.showType)
    __show._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 70, 1)
    __show._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 117, 2)
    
    show = property(__show.value, __show.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}actuate uses Python identifier actuate
    __actuate = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'actuate'), 'actuate', '__httpwww_opengis_netgml3_2_LocationPropertyType_httpwww_w3_org1999xlinkactuate', _ImportedBinding_bindings_v1411_write__xlink.actuateType)
    __actuate._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 82, 1)
    __actuate._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 118, 2)
    
    actuate = property(__actuate.value, __actuate.set, None, None)

    _ElementMap.update({
        __Null.name() : __Null,
        __LocationString.name() : __LocationString,
        __LocationKeyWord.name() : __LocationKeyWord,
        __AbstractGeometry.name() : __AbstractGeometry
    })
    _AttributeMap.update({
        __remoteSchema.name() : __remoteSchema,
        __nilReason.name() : __nilReason,
        __type.name() : __type,
        __href.name() : __href,
        __role.name() : __role,
        __arcrole.name() : __arcrole,
        __title.name() : __title,
        __show.name() : __show,
        __actuate.name() : __actuate
    })
_module_typeBindings.LocationPropertyType = LocationPropertyType
_Namespace_gml.addCategoryObject('typeBinding', 'LocationPropertyType', LocationPropertyType)


# Complex type {http://www.opengis.net/gml/3.2}BoundedFeatureType with content type ELEMENT_ONLY
class BoundedFeatureType (AbstractFeatureType):
    """"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = True
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'BoundedFeatureType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 828, 1)
    _ElementMap = AbstractFeatureType._ElementMap.copy()
    _AttributeMap = AbstractFeatureType._AttributeMap.copy()
    # Base type is AbstractFeatureType
    
    # Element metaDataProperty ({http://www.opengis.net/gml/3.2}metaDataProperty) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element location ({http://www.opengis.net/gml/3.2}location) inherited from {http://www.opengis.net/gml/3.2}AbstractFeatureType
    
    # Element boundedBy ({http://www.opengis.net/gml/3.2}boundedBy) inherited from {http://www.opengis.net/gml/3.2}AbstractFeatureType
    
    # Element description ({http://www.opengis.net/gml/3.2}description) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element descriptionReference ({http://www.opengis.net/gml/3.2}descriptionReference) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element name ({http://www.opengis.net/gml/3.2}name) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element identifier ({http://www.opengis.net/gml/3.2}identifier) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Attribute id inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    _ElementMap.update({
        
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.BoundedFeatureType = BoundedFeatureType
_Namespace_gml.addCategoryObject('typeBinding', 'BoundedFeatureType', BoundedFeatureType)


# Complex type {http://www.opengis.net/gml/3.2}AbstractFeatureCollectionType with content type ELEMENT_ONLY
class AbstractFeatureCollectionType (AbstractFeatureType):
    """"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = True
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractFeatureCollectionType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 842, 1)
    _ElementMap = AbstractFeatureType._ElementMap.copy()
    _AttributeMap = AbstractFeatureType._AttributeMap.copy()
    # Base type is AbstractFeatureType
    
    # Element metaDataProperty ({http://www.opengis.net/gml/3.2}metaDataProperty) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element location ({http://www.opengis.net/gml/3.2}location) inherited from {http://www.opengis.net/gml/3.2}AbstractFeatureType
    
    # Element {http://www.opengis.net/gml/3.2}featureMember uses Python identifier featureMember
    __featureMember = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'featureMember'), 'featureMember', '__httpwww_opengis_netgml3_2_AbstractFeatureCollectionType_httpwww_opengis_netgml3_2featureMember', True, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 805, 1), )

    
    featureMember = property(__featureMember.value, __featureMember.set, None, '')

    
    # Element {http://www.opengis.net/gml/3.2}featureMembers uses Python identifier featureMembers
    __featureMembers = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'featureMembers'), 'featureMembers', '__httpwww_opengis_netgml3_2_AbstractFeatureCollectionType_httpwww_opengis_netgml3_2featureMembers', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 823, 1), )

    
    featureMembers = property(__featureMembers.value, __featureMembers.set, None, '')

    
    # Element boundedBy ({http://www.opengis.net/gml/3.2}boundedBy) inherited from {http://www.opengis.net/gml/3.2}AbstractFeatureType
    
    # Element description ({http://www.opengis.net/gml/3.2}description) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element descriptionReference ({http://www.opengis.net/gml/3.2}descriptionReference) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element name ({http://www.opengis.net/gml/3.2}name) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element identifier ({http://www.opengis.net/gml/3.2}identifier) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Attribute id inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    _ElementMap.update({
        __featureMember.name() : __featureMember,
        __featureMembers.name() : __featureMembers
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.AbstractFeatureCollectionType = AbstractFeatureCollectionType
_Namespace_gml.addCategoryObject('typeBinding', 'AbstractFeatureCollectionType', AbstractFeatureCollectionType)


# Complex type {http://www.opengis.net/gml/3.2}MovingObjectStatusType with content type ELEMENT_ONLY
class MovingObjectStatusType (AbstractTimeSliceType):
    """"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'MovingObjectStatusType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 1049, 1)
    _ElementMap = AbstractTimeSliceType._ElementMap.copy()
    _AttributeMap = AbstractTimeSliceType._AttributeMap.copy()
    # Base type is AbstractTimeSliceType
    
    # Element metaDataProperty ({http://www.opengis.net/gml/3.2}metaDataProperty) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element {http://www.opengis.net/gml/3.2}location uses Python identifier location
    __location = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'location'), 'location', '__httpwww_opengis_netgml3_2_MovingObjectStatusType_httpwww_opengis_netgml3_2location', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 761, 1), )

    
    location = property(__location.value, __location.set, None, '')

    
    # Element {http://www.opengis.net/gml/3.2}position uses Python identifier position
    __position = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'position'), 'position', '__httpwww_opengis_netgml3_2_MovingObjectStatusType_httpwww_opengis_netgml3_2position', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 1057, 6), )

    
    position = property(__position.value, __position.set, None, None)

    
    # Element {http://www.opengis.net/gml/3.2}speed uses Python identifier speed
    __speed = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'speed'), 'speed', '__httpwww_opengis_netgml3_2_MovingObjectStatusType_httpwww_opengis_netgml3_2speed', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 1063, 5), )

    
    speed = property(__speed.value, __speed.set, None, None)

    
    # Element {http://www.opengis.net/gml/3.2}bearing uses Python identifier bearing
    __bearing = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'bearing'), 'bearing', '__httpwww_opengis_netgml3_2_MovingObjectStatusType_httpwww_opengis_netgml3_2bearing', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 1064, 5), )

    
    bearing = property(__bearing.value, __bearing.set, None, None)

    
    # Element {http://www.opengis.net/gml/3.2}acceleration uses Python identifier acceleration
    __acceleration = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'acceleration'), 'acceleration', '__httpwww_opengis_netgml3_2_MovingObjectStatusType_httpwww_opengis_netgml3_2acceleration', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 1065, 5), )

    
    acceleration = property(__acceleration.value, __acceleration.set, None, None)

    
    # Element {http://www.opengis.net/gml/3.2}elevation uses Python identifier elevation
    __elevation = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'elevation'), 'elevation', '__httpwww_opengis_netgml3_2_MovingObjectStatusType_httpwww_opengis_netgml3_2elevation', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 1066, 5), )

    
    elevation = property(__elevation.value, __elevation.set, None, None)

    
    # Element {http://www.opengis.net/gml/3.2}status uses Python identifier status
    __status = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'status'), 'status', '__httpwww_opengis_netgml3_2_MovingObjectStatusType_httpwww_opengis_netgml3_2status', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 1073, 1), )

    
    status = property(__status.value, __status.set, None, '')

    
    # Element {http://www.opengis.net/gml/3.2}statusReference uses Python identifier statusReference
    __statusReference = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'statusReference'), 'statusReference', '__httpwww_opengis_netgml3_2_MovingObjectStatusType_httpwww_opengis_netgml3_2statusReference', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 1078, 1), )

    
    statusReference = property(__statusReference.value, __statusReference.set, None, '')

    
    # Element dataSource ({http://www.opengis.net/gml/3.2}dataSource) inherited from {http://www.opengis.net/gml/3.2}AbstractTimeSliceType
    
    # Element {http://www.opengis.net/gml/3.2}locationName uses Python identifier locationName
    __locationName = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'locationName'), 'locationName', '__httpwww_opengis_netgml3_2_MovingObjectStatusType_httpwww_opengis_netgml3_2locationName', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/feature.xsd', 76, 1), )

    
    locationName = property(__locationName.value, __locationName.set, None, 'The gml:locationName property element is a convenience property where the text value describes the location of the feature. If the location names are selected from a controlled list, then the list shall be identified in the codeSpace attribute.')

    
    # Element {http://www.opengis.net/gml/3.2}locationReference uses Python identifier locationReference
    __locationReference = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'locationReference'), 'locationReference', '__httpwww_opengis_netgml3_2_MovingObjectStatusType_httpwww_opengis_netgml3_2locationReference', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/feature.xsd', 81, 1), )

    
    locationReference = property(__locationReference.value, __locationReference.set, None, 'The gml:locationReference property element is a convenience property where the text value referenced by the xlink:href attribute describes the location of the feature.')

    
    # Element {http://www.opengis.net/gml/3.2}pos uses Python identifier pos
    __pos = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'pos'), 'pos', '__httpwww_opengis_netgml3_2_MovingObjectStatusType_httpwww_opengis_netgml3_2pos', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic0d1d.xsd', 87, 1), )

    
    pos = property(__pos.value, __pos.set, None, None)

    
    # Element description ({http://www.opengis.net/gml/3.2}description) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element descriptionReference ({http://www.opengis.net/gml/3.2}descriptionReference) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element name ({http://www.opengis.net/gml/3.2}name) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element identifier ({http://www.opengis.net/gml/3.2}identifier) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element validTime ({http://www.opengis.net/gml/3.2}validTime) inherited from {http://www.opengis.net/gml/3.2}AbstractTimeSliceType
    
    # Attribute id inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    _ElementMap.update({
        __location.name() : __location,
        __position.name() : __position,
        __speed.name() : __speed,
        __bearing.name() : __bearing,
        __acceleration.name() : __acceleration,
        __elevation.name() : __elevation,
        __status.name() : __status,
        __statusReference.name() : __statusReference,
        __locationName.name() : __locationName,
        __locationReference.name() : __locationReference,
        __pos.name() : __pos
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.MovingObjectStatusType = MovingObjectStatusType
_Namespace_gml.addCategoryObject('typeBinding', 'MovingObjectStatusType', MovingObjectStatusType)


# Complex type {http://www.opengis.net/gml/3.2}DefinitionType with content type ELEMENT_ONLY
class DefinitionType (DefinitionBaseType):
    """Complex type {http://www.opengis.net/gml/3.2}DefinitionType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'DefinitionType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 45, 1)
    _ElementMap = DefinitionBaseType._ElementMap.copy()
    _AttributeMap = DefinitionBaseType._AttributeMap.copy()
    # Base type is DefinitionBaseType
    
    # Element metaDataProperty ({http://www.opengis.net/gml/3.2}metaDataProperty) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element {http://www.opengis.net/gml/3.2}remarks uses Python identifier remarks
    __remarks = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'remarks'), 'remarks', '__httpwww_opengis_netgml3_2_DefinitionType_httpwww_opengis_netgml3_2remarks', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 54, 1), )

    
    remarks = property(__remarks.value, __remarks.set, None, None)

    
    # Element description ({http://www.opengis.net/gml/3.2}description) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element descriptionReference ({http://www.opengis.net/gml/3.2}descriptionReference) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element name ({http://www.opengis.net/gml/3.2}name) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element identifier ({http://www.opengis.net/gml/3.2}identifier) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Attribute id_ inherited from {http://www.opengis.net/gml/3.2}DefinitionBaseType
    _ElementMap.update({
        __remarks.name() : __remarks
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.DefinitionType = DefinitionType
_Namespace_gml.addCategoryObject('typeBinding', 'DefinitionType', DefinitionType)


# Complex type {http://www.opengis.net/gml/3.2}DictionaryEntryType with content type ELEMENT_ONLY
class DictionaryEntryType (AbstractMemberType):
    """Complex type {http://www.opengis.net/gml/3.2}DictionaryEntryType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'DictionaryEntryType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 80, 1)
    _ElementMap = AbstractMemberType._ElementMap.copy()
    _AttributeMap = AbstractMemberType._AttributeMap.copy()
    # Base type is AbstractMemberType
    
    # Element {http://www.opengis.net/gml/3.2}Definition uses Python identifier Definition
    __Definition = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'Definition'), 'Definition', '__httpwww_opengis_netgml3_2_DictionaryEntryType_httpwww_opengis_netgml3_2Definition', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 21, 1), )

    
    Definition = property(__Definition.value, __Definition.set, None, 'The basic gml:Definition element specifies a definition, which can be included in or referenced by a dictionary. \nThe content model for a generic definition is a derivation from gml:AbstractGMLType.  \nThe gml:description property element shall hold the definition if this can be captured in a simple text string, or the gml:descriptionReference property element may carry a link to a description elsewhere.\nThe gml:identifier element shall provide one identifier identifying this definition. The identifier shall be unique within the dictionaries using this definition. \nThe gml:name elements shall provide zero or more terms and synonyms for which this is the definition.\nThe gml:remarks element shall be used to hold additional textual information that is not conceptually part of the definition but is useful in understanding the definition.')

    
    # Attribute {http://www.opengis.net/gml/3.2}remoteSchema uses Python identifier remoteSchema
    __remoteSchema = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gml, 'remoteSchema'), 'remoteSchema', '__httpwww_opengis_netgml3_2_DictionaryEntryType_httpwww_opengis_netgml3_2remoteSchema', pyxb.binding.datatypes.anyURI)
    __remoteSchema._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 638, 1)
    __remoteSchema._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 52, 2)
    
    remoteSchema = property(__remoteSchema.value, __remoteSchema.set, None, '')

    
    # Attribute nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'nilReason'), 'nilReason', '__httpwww_opengis_netgml3_2_DictionaryEntryType_nilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 51, 2)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 51, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    
    # Attribute owns inherited from {http://www.opengis.net/gml/3.2}AbstractMemberType
    
    # Attribute {http://www.w3.org/1999/xlink}type uses Python identifier type
    __type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'type'), 'type', '__httpwww_opengis_netgml3_2_DictionaryEntryType_httpwww_w3_org1999xlinktype', _ImportedBinding_bindings_v1411_write__xlink.typeType, fixed=True, unicode_default='simple')
    __type._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 29, 1)
    __type._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 112, 2)
    
    type = property(__type.value, __type.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}href uses Python identifier href
    __href = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'href'), 'href', '__httpwww_opengis_netgml3_2_DictionaryEntryType_httpwww_w3_org1999xlinkhref', _ImportedBinding_bindings_v1411_write__xlink.hrefType)
    __href._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 42, 1)
    __href._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 113, 2)
    
    href = property(__href.value, __href.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}role uses Python identifier role
    __role = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'role'), 'role', '__httpwww_opengis_netgml3_2_DictionaryEntryType_httpwww_w3_org1999xlinkrole', _ImportedBinding_bindings_v1411_write__xlink.roleType)
    __role._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 48, 1)
    __role._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 114, 2)
    
    role = property(__role.value, __role.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}arcrole uses Python identifier arcrole
    __arcrole = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'arcrole'), 'arcrole', '__httpwww_opengis_netgml3_2_DictionaryEntryType_httpwww_w3_org1999xlinkarcrole', _ImportedBinding_bindings_v1411_write__xlink.arcroleType)
    __arcrole._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 56, 1)
    __arcrole._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 115, 2)
    
    arcrole = property(__arcrole.value, __arcrole.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}title uses Python identifier title
    __title = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'title'), 'title', '__httpwww_opengis_netgml3_2_DictionaryEntryType_httpwww_w3_org1999xlinktitle', _ImportedBinding_bindings_v1411_write__xlink.titleAttrType)
    __title._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 64, 1)
    __title._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 116, 2)
    
    title = property(__title.value, __title.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}show uses Python identifier show
    __show = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'show'), 'show', '__httpwww_opengis_netgml3_2_DictionaryEntryType_httpwww_w3_org1999xlinkshow', _ImportedBinding_bindings_v1411_write__xlink.showType)
    __show._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 70, 1)
    __show._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 117, 2)
    
    show = property(__show.value, __show.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}actuate uses Python identifier actuate
    __actuate = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'actuate'), 'actuate', '__httpwww_opengis_netgml3_2_DictionaryEntryType_httpwww_w3_org1999xlinkactuate', _ImportedBinding_bindings_v1411_write__xlink.actuateType)
    __actuate._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 82, 1)
    __actuate._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 118, 2)
    
    actuate = property(__actuate.value, __actuate.set, None, None)

    _ElementMap.update({
        __Definition.name() : __Definition
    })
    _AttributeMap.update({
        __remoteSchema.name() : __remoteSchema,
        __nilReason.name() : __nilReason,
        __type.name() : __type,
        __href.name() : __href,
        __role.name() : __role,
        __arcrole.name() : __arcrole,
        __title.name() : __title,
        __show.name() : __show,
        __actuate.name() : __actuate
    })
_module_typeBindings.DictionaryEntryType = DictionaryEntryType
_Namespace_gml.addCategoryObject('typeBinding', 'DictionaryEntryType', DictionaryEntryType)


# Complex type {http://www.opengis.net/gml/3.2}DirectionPropertyType with content type ELEMENT_ONLY
class DirectionPropertyType (pyxb.binding.basis.complexTypeDefinition):
    """Complex type {http://www.opengis.net/gml/3.2}DirectionPropertyType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'DirectionPropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/direction.xsd', 20, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.opengis.net/gml/3.2}DirectionVector uses Python identifier DirectionVector
    __DirectionVector = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'DirectionVector'), 'DirectionVector', '__httpwww_opengis_netgml3_2_DirectionPropertyType_httpwww_opengis_netgml3_2DirectionVector', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/direction.xsd', 22, 3), )

    
    DirectionVector = property(__DirectionVector.value, __DirectionVector.set, None, None)

    
    # Element {http://www.opengis.net/gml/3.2}DirectionDescription uses Python identifier DirectionDescription
    __DirectionDescription = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'DirectionDescription'), 'DirectionDescription', '__httpwww_opengis_netgml3_2_DirectionPropertyType_httpwww_opengis_netgml3_2DirectionDescription', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/direction.xsd', 23, 3), )

    
    DirectionDescription = property(__DirectionDescription.value, __DirectionDescription.set, None, None)

    
    # Element {http://www.opengis.net/gml/3.2}CompassPoint uses Python identifier CompassPoint
    __CompassPoint = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'CompassPoint'), 'CompassPoint', '__httpwww_opengis_netgml3_2_DirectionPropertyType_httpwww_opengis_netgml3_2CompassPoint', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/direction.xsd', 24, 3), )

    
    CompassPoint = property(__CompassPoint.value, __CompassPoint.set, None, None)

    
    # Element {http://www.opengis.net/gml/3.2}DirectionKeyword uses Python identifier DirectionKeyword
    __DirectionKeyword = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'DirectionKeyword'), 'DirectionKeyword', '__httpwww_opengis_netgml3_2_DirectionPropertyType_httpwww_opengis_netgml3_2DirectionKeyword', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/direction.xsd', 25, 3), )

    
    DirectionKeyword = property(__DirectionKeyword.value, __DirectionKeyword.set, None, None)

    
    # Element {http://www.opengis.net/gml/3.2}DirectionString uses Python identifier DirectionString
    __DirectionString = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'DirectionString'), 'DirectionString', '__httpwww_opengis_netgml3_2_DirectionPropertyType_httpwww_opengis_netgml3_2DirectionString', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/direction.xsd', 26, 3), )

    
    DirectionString = property(__DirectionString.value, __DirectionString.set, None, None)

    
    # Attribute {http://www.opengis.net/gml/3.2}remoteSchema uses Python identifier remoteSchema
    __remoteSchema = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gml, 'remoteSchema'), 'remoteSchema', '__httpwww_opengis_netgml3_2_DirectionPropertyType_httpwww_opengis_netgml3_2remoteSchema', pyxb.binding.datatypes.anyURI)
    __remoteSchema._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 638, 1)
    __remoteSchema._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 52, 2)
    
    remoteSchema = property(__remoteSchema.value, __remoteSchema.set, None, '')

    
    # Attribute nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'nilReason'), 'nilReason', '__httpwww_opengis_netgml3_2_DirectionPropertyType_nilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 51, 2)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 51, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    
    # Attribute owns uses Python identifier owns
    __owns = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'owns'), 'owns', '__httpwww_opengis_netgml3_2_DirectionPropertyType_owns', pyxb.binding.datatypes.boolean, unicode_default='false')
    __owns._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 79, 2)
    __owns._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 79, 2)
    
    owns = property(__owns.value, __owns.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}type uses Python identifier type
    __type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'type'), 'type', '__httpwww_opengis_netgml3_2_DirectionPropertyType_httpwww_w3_org1999xlinktype', _ImportedBinding_bindings_v1411_write__xlink.typeType, fixed=True, unicode_default='simple')
    __type._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 29, 1)
    __type._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 112, 2)
    
    type = property(__type.value, __type.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}href uses Python identifier href
    __href = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'href'), 'href', '__httpwww_opengis_netgml3_2_DirectionPropertyType_httpwww_w3_org1999xlinkhref', _ImportedBinding_bindings_v1411_write__xlink.hrefType)
    __href._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 42, 1)
    __href._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 113, 2)
    
    href = property(__href.value, __href.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}role uses Python identifier role
    __role = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'role'), 'role', '__httpwww_opengis_netgml3_2_DirectionPropertyType_httpwww_w3_org1999xlinkrole', _ImportedBinding_bindings_v1411_write__xlink.roleType)
    __role._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 48, 1)
    __role._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 114, 2)
    
    role = property(__role.value, __role.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}arcrole uses Python identifier arcrole
    __arcrole = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'arcrole'), 'arcrole', '__httpwww_opengis_netgml3_2_DirectionPropertyType_httpwww_w3_org1999xlinkarcrole', _ImportedBinding_bindings_v1411_write__xlink.arcroleType)
    __arcrole._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 56, 1)
    __arcrole._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 115, 2)
    
    arcrole = property(__arcrole.value, __arcrole.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}title uses Python identifier title
    __title = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'title'), 'title', '__httpwww_opengis_netgml3_2_DirectionPropertyType_httpwww_w3_org1999xlinktitle', _ImportedBinding_bindings_v1411_write__xlink.titleAttrType)
    __title._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 64, 1)
    __title._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 116, 2)
    
    title = property(__title.value, __title.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}show uses Python identifier show
    __show = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'show'), 'show', '__httpwww_opengis_netgml3_2_DirectionPropertyType_httpwww_w3_org1999xlinkshow', _ImportedBinding_bindings_v1411_write__xlink.showType)
    __show._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 70, 1)
    __show._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 117, 2)
    
    show = property(__show.value, __show.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}actuate uses Python identifier actuate
    __actuate = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'actuate'), 'actuate', '__httpwww_opengis_netgml3_2_DirectionPropertyType_httpwww_w3_org1999xlinkactuate', _ImportedBinding_bindings_v1411_write__xlink.actuateType)
    __actuate._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 82, 1)
    __actuate._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 118, 2)
    
    actuate = property(__actuate.value, __actuate.set, None, None)

    _ElementMap.update({
        __DirectionVector.name() : __DirectionVector,
        __DirectionDescription.name() : __DirectionDescription,
        __CompassPoint.name() : __CompassPoint,
        __DirectionKeyword.name() : __DirectionKeyword,
        __DirectionString.name() : __DirectionString
    })
    _AttributeMap.update({
        __remoteSchema.name() : __remoteSchema,
        __nilReason.name() : __nilReason,
        __owns.name() : __owns,
        __type.name() : __type,
        __href.name() : __href,
        __role.name() : __role,
        __arcrole.name() : __arcrole,
        __title.name() : __title,
        __show.name() : __show,
        __actuate.name() : __actuate
    })
_module_typeBindings.DirectionPropertyType = DirectionPropertyType
_Namespace_gml.addCategoryObject('typeBinding', 'DirectionPropertyType', DirectionPropertyType)


# Complex type {http://www.opengis.net/gml/3.2}DynamicFeatureType with content type ELEMENT_ONLY
class DynamicFeatureType (AbstractFeatureType):
    """Complex type {http://www.opengis.net/gml/3.2}DynamicFeatureType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'DynamicFeatureType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dynamicFeature.xsd', 44, 1)
    _ElementMap = AbstractFeatureType._ElementMap.copy()
    _AttributeMap = AbstractFeatureType._AttributeMap.copy()
    # Base type is AbstractFeatureType
    
    # Element metaDataProperty ({http://www.opengis.net/gml/3.2}metaDataProperty) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element location ({http://www.opengis.net/gml/3.2}location) inherited from {http://www.opengis.net/gml/3.2}AbstractFeatureType
    
    # Element {http://www.opengis.net/gml/3.2}dataSource uses Python identifier dataSource
    __dataSource = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'dataSource'), 'dataSource', '__httpwww_opengis_netgml3_2_DynamicFeatureType_httpwww_opengis_netgml3_2dataSource', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dynamicFeature.xsd', 17, 1), )

    
    dataSource = property(__dataSource.value, __dataSource.set, None, 'Evidence is represented by a simple gml:dataSource or gml:dataSourceReference property that indicates the source of the temporal data. The remote link attributes of the gml:dataSource element have been deprecated along with its current type.')

    
    # Element {http://www.opengis.net/gml/3.2}dataSourceReference uses Python identifier dataSourceReference
    __dataSourceReference = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'dataSourceReference'), 'dataSourceReference', '__httpwww_opengis_netgml3_2_DynamicFeatureType_httpwww_opengis_netgml3_2dataSourceReference', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dynamicFeature.xsd', 22, 1), )

    
    dataSourceReference = property(__dataSourceReference.value, __dataSourceReference.set, None, 'Evidence is represented by a simple gml:dataSource or gml:dataSourceReference property that indicates the source of the temporal data.')

    
    # Element {http://www.opengis.net/gml/3.2}history uses Python identifier history
    __history = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'history'), 'history', '__httpwww_opengis_netgml3_2_DynamicFeatureType_httpwww_opengis_netgml3_2history', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dynamicFeature.xsd', 97, 1), )

    
    history = property(__history.value, __history.set, None, 'A generic sequence of events constitute a gml:history of an object.\nThe gml:history element contains a set of elements in the substitution group headed by the abstract element gml:AbstractTimeSlice, representing the time-varying properties of interest. The history property of a dynamic feature associates a feature instance with a sequence of time slices (i.e. change events) that encapsulate the evolution of the feature.')

    
    # Element boundedBy ({http://www.opengis.net/gml/3.2}boundedBy) inherited from {http://www.opengis.net/gml/3.2}AbstractFeatureType
    
    # Element description ({http://www.opengis.net/gml/3.2}description) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element descriptionReference ({http://www.opengis.net/gml/3.2}descriptionReference) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element name ({http://www.opengis.net/gml/3.2}name) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element identifier ({http://www.opengis.net/gml/3.2}identifier) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element {http://www.opengis.net/gml/3.2}validTime uses Python identifier validTime
    __validTime = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'validTime'), 'validTime', '__httpwww_opengis_netgml3_2_DynamicFeatureType_httpwww_opengis_netgml3_2validTime', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporal.xsd', 52, 1), )

    
    validTime = property(__validTime.value, __validTime.set, None, 'gml:validTime is a convenience property element.')

    
    # Attribute id inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    _ElementMap.update({
        __dataSource.name() : __dataSource,
        __dataSourceReference.name() : __dataSourceReference,
        __history.name() : __history,
        __validTime.name() : __validTime
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.DynamicFeatureType = DynamicFeatureType
_Namespace_gml.addCategoryObject('typeBinding', 'DynamicFeatureType', DynamicFeatureType)


# Complex type {http://www.opengis.net/gml/3.2}DynamicFeatureMemberType with content type ELEMENT_ONLY
class DynamicFeatureMemberType (AbstractFeatureMemberType):
    """Complex type {http://www.opengis.net/gml/3.2}DynamicFeatureMemberType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'DynamicFeatureMemberType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dynamicFeature.xsd', 68, 1)
    _ElementMap = AbstractFeatureMemberType._ElementMap.copy()
    _AttributeMap = AbstractFeatureMemberType._AttributeMap.copy()
    # Base type is AbstractFeatureMemberType
    
    # Element {http://www.opengis.net/gml/3.2}DynamicFeature uses Python identifier DynamicFeature
    __DynamicFeature = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'DynamicFeature'), 'DynamicFeature', '__httpwww_opengis_netgml3_2_DynamicFeatureMemberType_httpwww_opengis_netgml3_2DynamicFeature', True, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dynamicFeature.xsd', 38, 1), )

    
    DynamicFeature = property(__DynamicFeature.value, __DynamicFeature.set, None, "States are captured by time-stamped instances of a feature. The content model extends the standard gml:AbstractFeatureType with the gml:dynamicProperties model group.\nEach time-stamped instance represents a 'snapshot' of a feature. The dynamic feature classes will normally be extended to suit particular applications.  A dynamic feature bears either a time stamp or a history.")

    
    # Attribute {http://www.opengis.net/gml/3.2}remoteSchema uses Python identifier remoteSchema
    __remoteSchema = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gml, 'remoteSchema'), 'remoteSchema', '__httpwww_opengis_netgml3_2_DynamicFeatureMemberType_httpwww_opengis_netgml3_2remoteSchema', pyxb.binding.datatypes.anyURI)
    __remoteSchema._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 638, 1)
    __remoteSchema._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 52, 2)
    
    remoteSchema = property(__remoteSchema.value, __remoteSchema.set, None, '')

    
    # Attribute nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'nilReason'), 'nilReason', '__httpwww_opengis_netgml3_2_DynamicFeatureMemberType_nilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 51, 2)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 51, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    
    # Attribute owns inherited from {http://www.opengis.net/gml/3.2}AbstractFeatureMemberType
    
    # Attribute {http://www.w3.org/1999/xlink}type uses Python identifier type
    __type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'type'), 'type', '__httpwww_opengis_netgml3_2_DynamicFeatureMemberType_httpwww_w3_org1999xlinktype', _ImportedBinding_bindings_v1411_write__xlink.typeType, fixed=True, unicode_default='simple')
    __type._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 29, 1)
    __type._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 112, 2)
    
    type = property(__type.value, __type.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}href uses Python identifier href
    __href = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'href'), 'href', '__httpwww_opengis_netgml3_2_DynamicFeatureMemberType_httpwww_w3_org1999xlinkhref', _ImportedBinding_bindings_v1411_write__xlink.hrefType)
    __href._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 42, 1)
    __href._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 113, 2)
    
    href = property(__href.value, __href.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}role uses Python identifier role
    __role = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'role'), 'role', '__httpwww_opengis_netgml3_2_DynamicFeatureMemberType_httpwww_w3_org1999xlinkrole', _ImportedBinding_bindings_v1411_write__xlink.roleType)
    __role._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 48, 1)
    __role._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 114, 2)
    
    role = property(__role.value, __role.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}arcrole uses Python identifier arcrole
    __arcrole = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'arcrole'), 'arcrole', '__httpwww_opengis_netgml3_2_DynamicFeatureMemberType_httpwww_w3_org1999xlinkarcrole', _ImportedBinding_bindings_v1411_write__xlink.arcroleType)
    __arcrole._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 56, 1)
    __arcrole._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 115, 2)
    
    arcrole = property(__arcrole.value, __arcrole.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}title uses Python identifier title
    __title = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'title'), 'title', '__httpwww_opengis_netgml3_2_DynamicFeatureMemberType_httpwww_w3_org1999xlinktitle', _ImportedBinding_bindings_v1411_write__xlink.titleAttrType)
    __title._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 64, 1)
    __title._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 116, 2)
    
    title = property(__title.value, __title.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}show uses Python identifier show
    __show = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'show'), 'show', '__httpwww_opengis_netgml3_2_DynamicFeatureMemberType_httpwww_w3_org1999xlinkshow', _ImportedBinding_bindings_v1411_write__xlink.showType)
    __show._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 70, 1)
    __show._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 117, 2)
    
    show = property(__show.value, __show.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}actuate uses Python identifier actuate
    __actuate = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'actuate'), 'actuate', '__httpwww_opengis_netgml3_2_DynamicFeatureMemberType_httpwww_w3_org1999xlinkactuate', _ImportedBinding_bindings_v1411_write__xlink.actuateType)
    __actuate._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 82, 1)
    __actuate._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 118, 2)
    
    actuate = property(__actuate.value, __actuate.set, None, None)

    _ElementMap.update({
        __DynamicFeature.name() : __DynamicFeature
    })
    _AttributeMap.update({
        __remoteSchema.name() : __remoteSchema,
        __nilReason.name() : __nilReason,
        __type.name() : __type,
        __href.name() : __href,
        __role.name() : __role,
        __arcrole.name() : __arcrole,
        __title.name() : __title,
        __show.name() : __show,
        __actuate.name() : __actuate
    })
_module_typeBindings.DynamicFeatureMemberType = DynamicFeatureMemberType
_Namespace_gml.addCategoryObject('typeBinding', 'DynamicFeatureMemberType', DynamicFeatureMemberType)


# Complex type {http://www.opengis.net/gml/3.2}FeaturePropertyType with content type ELEMENT_ONLY
class FeaturePropertyType (pyxb.binding.basis.complexTypeDefinition):
    """Complex type {http://www.opengis.net/gml/3.2}FeaturePropertyType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'FeaturePropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/feature.xsd', 38, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.opengis.net/gml/3.2}AbstractFeature uses Python identifier AbstractFeature
    __AbstractFeature = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractFeature'), 'AbstractFeature', '__httpwww_opengis_netgml3_2_FeaturePropertyType_httpwww_opengis_netgml3_2AbstractFeature', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/feature.xsd', 32, 1), )

    
    AbstractFeature = property(__AbstractFeature.value, __AbstractFeature.set, None, 'This abstract element serves as the head of a substitution group which may contain any elements whose content model is derived from gml:AbstractFeatureType.  This may be used as a variable in the construction of content models.  \ngml:AbstractFeature may be thought of as "anything that is a GML feature" and may be used to define variables or templates in which the value of a GML property is "any feature". This occurs in particular in a GML feature collection where the feature member properties contain one or multiple copies of gml:AbstractFeature respectively.')

    
    # Attribute {http://www.opengis.net/gml/3.2}remoteSchema uses Python identifier remoteSchema
    __remoteSchema = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gml, 'remoteSchema'), 'remoteSchema', '__httpwww_opengis_netgml3_2_FeaturePropertyType_httpwww_opengis_netgml3_2remoteSchema', pyxb.binding.datatypes.anyURI)
    __remoteSchema._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 638, 1)
    __remoteSchema._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 52, 2)
    
    remoteSchema = property(__remoteSchema.value, __remoteSchema.set, None, '')

    
    # Attribute nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'nilReason'), 'nilReason', '__httpwww_opengis_netgml3_2_FeaturePropertyType_nilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 51, 2)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 51, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    
    # Attribute owns uses Python identifier owns
    __owns = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'owns'), 'owns', '__httpwww_opengis_netgml3_2_FeaturePropertyType_owns', pyxb.binding.datatypes.boolean, unicode_default='false')
    __owns._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 79, 2)
    __owns._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 79, 2)
    
    owns = property(__owns.value, __owns.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}type uses Python identifier type
    __type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'type'), 'type', '__httpwww_opengis_netgml3_2_FeaturePropertyType_httpwww_w3_org1999xlinktype', _ImportedBinding_bindings_v1411_write__xlink.typeType, fixed=True, unicode_default='simple')
    __type._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 29, 1)
    __type._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 112, 2)
    
    type = property(__type.value, __type.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}href uses Python identifier href
    __href = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'href'), 'href', '__httpwww_opengis_netgml3_2_FeaturePropertyType_httpwww_w3_org1999xlinkhref', _ImportedBinding_bindings_v1411_write__xlink.hrefType)
    __href._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 42, 1)
    __href._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 113, 2)
    
    href = property(__href.value, __href.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}role uses Python identifier role
    __role = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'role'), 'role', '__httpwww_opengis_netgml3_2_FeaturePropertyType_httpwww_w3_org1999xlinkrole', _ImportedBinding_bindings_v1411_write__xlink.roleType)
    __role._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 48, 1)
    __role._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 114, 2)
    
    role = property(__role.value, __role.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}arcrole uses Python identifier arcrole
    __arcrole = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'arcrole'), 'arcrole', '__httpwww_opengis_netgml3_2_FeaturePropertyType_httpwww_w3_org1999xlinkarcrole', _ImportedBinding_bindings_v1411_write__xlink.arcroleType)
    __arcrole._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 56, 1)
    __arcrole._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 115, 2)
    
    arcrole = property(__arcrole.value, __arcrole.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}title uses Python identifier title
    __title = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'title'), 'title', '__httpwww_opengis_netgml3_2_FeaturePropertyType_httpwww_w3_org1999xlinktitle', _ImportedBinding_bindings_v1411_write__xlink.titleAttrType)
    __title._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 64, 1)
    __title._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 116, 2)
    
    title = property(__title.value, __title.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}show uses Python identifier show
    __show = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'show'), 'show', '__httpwww_opengis_netgml3_2_FeaturePropertyType_httpwww_w3_org1999xlinkshow', _ImportedBinding_bindings_v1411_write__xlink.showType)
    __show._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 70, 1)
    __show._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 117, 2)
    
    show = property(__show.value, __show.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}actuate uses Python identifier actuate
    __actuate = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'actuate'), 'actuate', '__httpwww_opengis_netgml3_2_FeaturePropertyType_httpwww_w3_org1999xlinkactuate', _ImportedBinding_bindings_v1411_write__xlink.actuateType)
    __actuate._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 82, 1)
    __actuate._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 118, 2)
    
    actuate = property(__actuate.value, __actuate.set, None, None)

    _ElementMap.update({
        __AbstractFeature.name() : __AbstractFeature
    })
    _AttributeMap.update({
        __remoteSchema.name() : __remoteSchema,
        __nilReason.name() : __nilReason,
        __owns.name() : __owns,
        __type.name() : __type,
        __href.name() : __href,
        __role.name() : __role,
        __arcrole.name() : __arcrole,
        __title.name() : __title,
        __show.name() : __show,
        __actuate.name() : __actuate
    })
_module_typeBindings.FeaturePropertyType = FeaturePropertyType
_Namespace_gml.addCategoryObject('typeBinding', 'FeaturePropertyType', FeaturePropertyType)


# Complex type {http://www.opengis.net/gml/3.2}BoundingShapeType with content type ELEMENT_ONLY
class BoundingShapeType (pyxb.binding.basis.complexTypeDefinition):
    """Complex type {http://www.opengis.net/gml/3.2}BoundingShapeType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'BoundingShapeType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/feature.xsd', 50, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.opengis.net/gml/3.2}Null uses Python identifier Null
    __Null = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'Null'), 'Null', '__httpwww_opengis_netgml3_2_BoundingShapeType_httpwww_opengis_netgml3_2Null', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 13, 1), )

    
    Null = property(__Null.value, __Null.set, None, '')

    
    # Element {http://www.opengis.net/gml/3.2}Envelope uses Python identifier Envelope
    __Envelope = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'Envelope'), 'Envelope', '__httpwww_opengis_netgml3_2_BoundingShapeType_httpwww_opengis_netgml3_2Envelope', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic0d1d.xsd', 148, 1), )

    
    Envelope = property(__Envelope.value, __Envelope.set, None, 'Envelope defines an extent using a pair of positions defining opposite corners in arbitrary dimensions. The first direct position is the "lower corner" (a coordinate position consisting of all the minimal ordinates for each dimension for all points within the envelope), the second one the "upper corner" (a coordinate position consisting of all the maximal ordinates for each dimension for all points within the envelope).\nThe use of the properties "coordinates" and "pos" has been deprecated. The explicitly named properties "lowerCorner" and "upperCorner" shall be used instead.')

    
    # Attribute nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'nilReason'), 'nilReason', '__httpwww_opengis_netgml3_2_BoundingShapeType_nilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/feature.xsd', 57, 2)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/feature.xsd', 57, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    _ElementMap.update({
        __Null.name() : __Null,
        __Envelope.name() : __Envelope
    })
    _AttributeMap.update({
        __nilReason.name() : __nilReason
    })
_module_typeBindings.BoundingShapeType = BoundingShapeType
_Namespace_gml.addCategoryObject('typeBinding', 'BoundingShapeType', BoundingShapeType)


# Complex type {http://www.opengis.net/gml/3.2}EnvelopeWithTimePeriodType with content type ELEMENT_ONLY
class EnvelopeWithTimePeriodType (EnvelopeType):
    """Complex type {http://www.opengis.net/gml/3.2}EnvelopeWithTimePeriodType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'EnvelopeWithTimePeriodType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/feature.xsd', 65, 1)
    _ElementMap = EnvelopeType._ElementMap.copy()
    _AttributeMap = EnvelopeType._AttributeMap.copy()
    # Base type is EnvelopeType
    
    # Element coordinates ({http://www.opengis.net/gml/3.2}coordinates) inherited from {http://www.opengis.net/gml/3.2}EnvelopeType
    
    # Element {http://www.opengis.net/gml/3.2}beginPosition uses Python identifier beginPosition
    __beginPosition = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'beginPosition'), 'beginPosition', '__httpwww_opengis_netgml3_2_EnvelopeWithTimePeriodType_httpwww_opengis_netgml3_2beginPosition', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/feature.xsd', 69, 5), )

    
    beginPosition = property(__beginPosition.value, __beginPosition.set, None, None)

    
    # Element {http://www.opengis.net/gml/3.2}endPosition uses Python identifier endPosition
    __endPosition = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'endPosition'), 'endPosition', '__httpwww_opengis_netgml3_2_EnvelopeWithTimePeriodType_httpwww_opengis_netgml3_2endPosition', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/feature.xsd', 70, 5), )

    
    endPosition = property(__endPosition.value, __endPosition.set, None, None)

    
    # Element pos ({http://www.opengis.net/gml/3.2}pos) inherited from {http://www.opengis.net/gml/3.2}EnvelopeType
    
    # Element lowerCorner ({http://www.opengis.net/gml/3.2}lowerCorner) inherited from {http://www.opengis.net/gml/3.2}EnvelopeType
    
    # Element upperCorner ({http://www.opengis.net/gml/3.2}upperCorner) inherited from {http://www.opengis.net/gml/3.2}EnvelopeType
    
    # Attribute frame uses Python identifier frame
    __frame = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'frame'), 'frame', '__httpwww_opengis_netgml3_2_EnvelopeWithTimePeriodType_frame', pyxb.binding.datatypes.anyURI, unicode_default='#ISO-8601')
    __frame._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/feature.xsd', 72, 4)
    __frame._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/feature.xsd', 72, 4)
    
    frame = property(__frame.value, __frame.set, None, None)

    
    # Attribute srsName inherited from {http://www.opengis.net/gml/3.2}EnvelopeType
    
    # Attribute srsDimension inherited from {http://www.opengis.net/gml/3.2}EnvelopeType
    
    # Attribute axisLabels inherited from {http://www.opengis.net/gml/3.2}EnvelopeType
    
    # Attribute uomLabels inherited from {http://www.opengis.net/gml/3.2}EnvelopeType
    _ElementMap.update({
        __beginPosition.name() : __beginPosition,
        __endPosition.name() : __endPosition
    })
    _AttributeMap.update({
        __frame.name() : __frame
    })
_module_typeBindings.EnvelopeWithTimePeriodType = EnvelopeWithTimePeriodType
_Namespace_gml.addCategoryObject('typeBinding', 'EnvelopeWithTimePeriodType', EnvelopeWithTimePeriodType)


# Complex type {http://www.opengis.net/gml/3.2}AbstractGeometricAggregateType with content type ELEMENT_ONLY
class AbstractGeometricAggregateType (AbstractGeometryType):
    """Complex type {http://www.opengis.net/gml/3.2}AbstractGeometricAggregateType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = True
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractGeometricAggregateType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryAggregates.xsd', 15, 1)
    _ElementMap = AbstractGeometryType._ElementMap.copy()
    _AttributeMap = AbstractGeometryType._AttributeMap.copy()
    # Base type is AbstractGeometryType
    
    # Element metaDataProperty ({http://www.opengis.net/gml/3.2}metaDataProperty) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element description ({http://www.opengis.net/gml/3.2}description) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element descriptionReference ({http://www.opengis.net/gml/3.2}descriptionReference) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element name ({http://www.opengis.net/gml/3.2}name) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element identifier ({http://www.opengis.net/gml/3.2}identifier) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Attribute srsName inherited from {http://www.opengis.net/gml/3.2}AbstractGeometryType
    
    # Attribute srsDimension inherited from {http://www.opengis.net/gml/3.2}AbstractGeometryType
    
    # Attribute axisLabels inherited from {http://www.opengis.net/gml/3.2}AbstractGeometryType
    
    # Attribute uomLabels inherited from {http://www.opengis.net/gml/3.2}AbstractGeometryType
    
    # Attribute id inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Attribute aggregationType uses Python identifier aggregationType
    __aggregationType = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'aggregationType'), 'aggregationType', '__httpwww_opengis_netgml3_2_AbstractGeometricAggregateType_aggregationType', _module_typeBindings.AggregationType)
    __aggregationType._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 158, 2)
    __aggregationType._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 158, 2)
    
    aggregationType = property(__aggregationType.value, __aggregationType.set, None, None)

    _ElementMap.update({
        
    })
    _AttributeMap.update({
        __aggregationType.name() : __aggregationType
    })
_module_typeBindings.AbstractGeometricAggregateType = AbstractGeometricAggregateType
_Namespace_gml.addCategoryObject('typeBinding', 'AbstractGeometricAggregateType', AbstractGeometricAggregateType)


# Complex type {http://www.opengis.net/gml/3.2}MultiGeometryPropertyType with content type ELEMENT_ONLY
class MultiGeometryPropertyType (pyxb.binding.basis.complexTypeDefinition):
    """A property that has a geometric aggregate as its value domain may either be an appropriate geometry element encapsulated in an element of this type or an XLink reference to a remote geometry element (where remote includes geometry elements located elsewhere in the same document). Either the reference or the contained element shall be given, but neither both nor none."""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'MultiGeometryPropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryAggregates.xsd', 53, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.opengis.net/gml/3.2}AbstractGeometricAggregate uses Python identifier AbstractGeometricAggregate
    __AbstractGeometricAggregate = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractGeometricAggregate'), 'AbstractGeometricAggregate', '__httpwww_opengis_netgml3_2_MultiGeometryPropertyType_httpwww_opengis_netgml3_2AbstractGeometricAggregate', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryAggregates.xsd', 22, 1), )

    
    AbstractGeometricAggregate = property(__AbstractGeometricAggregate.value, __AbstractGeometricAggregate.set, None, 'gml:AbstractGeometricAggregate is the abstract head of the substitution group for all geometric aggregates.')

    
    # Attribute {http://www.opengis.net/gml/3.2}remoteSchema uses Python identifier remoteSchema
    __remoteSchema = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gml, 'remoteSchema'), 'remoteSchema', '__httpwww_opengis_netgml3_2_MultiGeometryPropertyType_httpwww_opengis_netgml3_2remoteSchema', pyxb.binding.datatypes.anyURI)
    __remoteSchema._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 638, 1)
    __remoteSchema._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 52, 2)
    
    remoteSchema = property(__remoteSchema.value, __remoteSchema.set, None, '')

    
    # Attribute nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'nilReason'), 'nilReason', '__httpwww_opengis_netgml3_2_MultiGeometryPropertyType_nilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 51, 2)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 51, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    
    # Attribute owns uses Python identifier owns
    __owns = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'owns'), 'owns', '__httpwww_opengis_netgml3_2_MultiGeometryPropertyType_owns', pyxb.binding.datatypes.boolean, unicode_default='false')
    __owns._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 79, 2)
    __owns._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 79, 2)
    
    owns = property(__owns.value, __owns.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}type uses Python identifier type
    __type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'type'), 'type', '__httpwww_opengis_netgml3_2_MultiGeometryPropertyType_httpwww_w3_org1999xlinktype', _ImportedBinding_bindings_v1411_write__xlink.typeType, fixed=True, unicode_default='simple')
    __type._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 29, 1)
    __type._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 112, 2)
    
    type = property(__type.value, __type.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}href uses Python identifier href
    __href = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'href'), 'href', '__httpwww_opengis_netgml3_2_MultiGeometryPropertyType_httpwww_w3_org1999xlinkhref', _ImportedBinding_bindings_v1411_write__xlink.hrefType)
    __href._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 42, 1)
    __href._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 113, 2)
    
    href = property(__href.value, __href.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}role uses Python identifier role
    __role = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'role'), 'role', '__httpwww_opengis_netgml3_2_MultiGeometryPropertyType_httpwww_w3_org1999xlinkrole', _ImportedBinding_bindings_v1411_write__xlink.roleType)
    __role._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 48, 1)
    __role._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 114, 2)
    
    role = property(__role.value, __role.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}arcrole uses Python identifier arcrole
    __arcrole = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'arcrole'), 'arcrole', '__httpwww_opengis_netgml3_2_MultiGeometryPropertyType_httpwww_w3_org1999xlinkarcrole', _ImportedBinding_bindings_v1411_write__xlink.arcroleType)
    __arcrole._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 56, 1)
    __arcrole._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 115, 2)
    
    arcrole = property(__arcrole.value, __arcrole.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}title uses Python identifier title
    __title = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'title'), 'title', '__httpwww_opengis_netgml3_2_MultiGeometryPropertyType_httpwww_w3_org1999xlinktitle', _ImportedBinding_bindings_v1411_write__xlink.titleAttrType)
    __title._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 64, 1)
    __title._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 116, 2)
    
    title = property(__title.value, __title.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}show uses Python identifier show
    __show = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'show'), 'show', '__httpwww_opengis_netgml3_2_MultiGeometryPropertyType_httpwww_w3_org1999xlinkshow', _ImportedBinding_bindings_v1411_write__xlink.showType)
    __show._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 70, 1)
    __show._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 117, 2)
    
    show = property(__show.value, __show.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}actuate uses Python identifier actuate
    __actuate = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'actuate'), 'actuate', '__httpwww_opengis_netgml3_2_MultiGeometryPropertyType_httpwww_w3_org1999xlinkactuate', _ImportedBinding_bindings_v1411_write__xlink.actuateType)
    __actuate._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 82, 1)
    __actuate._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 118, 2)
    
    actuate = property(__actuate.value, __actuate.set, None, None)

    _ElementMap.update({
        __AbstractGeometricAggregate.name() : __AbstractGeometricAggregate
    })
    _AttributeMap.update({
        __remoteSchema.name() : __remoteSchema,
        __nilReason.name() : __nilReason,
        __owns.name() : __owns,
        __type.name() : __type,
        __href.name() : __href,
        __role.name() : __role,
        __arcrole.name() : __arcrole,
        __title.name() : __title,
        __show.name() : __show,
        __actuate.name() : __actuate
    })
_module_typeBindings.MultiGeometryPropertyType = MultiGeometryPropertyType
_Namespace_gml.addCategoryObject('typeBinding', 'MultiGeometryPropertyType', MultiGeometryPropertyType)


# Complex type {http://www.opengis.net/gml/3.2}MultiPointPropertyType with content type ELEMENT_ONLY
class MultiPointPropertyType (pyxb.binding.basis.complexTypeDefinition):
    """A property that has a collection of points as its value domain may either be an appropriate geometry element encapsulated in an element of this type or an XLink reference to a remote geometry element (where remote includes geometry elements located elsewhere in the same document). Either the reference or the contained element shall be given, but neither both nor none."""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'MultiPointPropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryAggregates.xsd', 89, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.opengis.net/gml/3.2}MultiPoint uses Python identifier MultiPoint
    __MultiPoint = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'MultiPoint'), 'MultiPoint', '__httpwww_opengis_netgml3_2_MultiPointPropertyType_httpwww_opengis_netgml3_2MultiPoint', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryAggregates.xsd', 73, 1), )

    
    MultiPoint = property(__MultiPoint.value, __MultiPoint.set, None, 'A gml:MultiPoint consists of one or more gml:Points.\nThe members of the geometric aggregate may be specified either using the "standard" property (gml:pointMember) or the array property (gml:pointMembers). It is also valid to use both the "standard" and the array properties in the same collection.')

    
    # Attribute {http://www.opengis.net/gml/3.2}remoteSchema uses Python identifier remoteSchema
    __remoteSchema = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gml, 'remoteSchema'), 'remoteSchema', '__httpwww_opengis_netgml3_2_MultiPointPropertyType_httpwww_opengis_netgml3_2remoteSchema', pyxb.binding.datatypes.anyURI)
    __remoteSchema._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 638, 1)
    __remoteSchema._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 52, 2)
    
    remoteSchema = property(__remoteSchema.value, __remoteSchema.set, None, '')

    
    # Attribute nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'nilReason'), 'nilReason', '__httpwww_opengis_netgml3_2_MultiPointPropertyType_nilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 51, 2)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 51, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    
    # Attribute owns uses Python identifier owns
    __owns = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'owns'), 'owns', '__httpwww_opengis_netgml3_2_MultiPointPropertyType_owns', pyxb.binding.datatypes.boolean, unicode_default='false')
    __owns._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 79, 2)
    __owns._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 79, 2)
    
    owns = property(__owns.value, __owns.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}type uses Python identifier type
    __type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'type'), 'type', '__httpwww_opengis_netgml3_2_MultiPointPropertyType_httpwww_w3_org1999xlinktype', _ImportedBinding_bindings_v1411_write__xlink.typeType, fixed=True, unicode_default='simple')
    __type._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 29, 1)
    __type._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 112, 2)
    
    type = property(__type.value, __type.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}href uses Python identifier href
    __href = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'href'), 'href', '__httpwww_opengis_netgml3_2_MultiPointPropertyType_httpwww_w3_org1999xlinkhref', _ImportedBinding_bindings_v1411_write__xlink.hrefType)
    __href._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 42, 1)
    __href._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 113, 2)
    
    href = property(__href.value, __href.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}role uses Python identifier role
    __role = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'role'), 'role', '__httpwww_opengis_netgml3_2_MultiPointPropertyType_httpwww_w3_org1999xlinkrole', _ImportedBinding_bindings_v1411_write__xlink.roleType)
    __role._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 48, 1)
    __role._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 114, 2)
    
    role = property(__role.value, __role.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}arcrole uses Python identifier arcrole
    __arcrole = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'arcrole'), 'arcrole', '__httpwww_opengis_netgml3_2_MultiPointPropertyType_httpwww_w3_org1999xlinkarcrole', _ImportedBinding_bindings_v1411_write__xlink.arcroleType)
    __arcrole._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 56, 1)
    __arcrole._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 115, 2)
    
    arcrole = property(__arcrole.value, __arcrole.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}title uses Python identifier title
    __title = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'title'), 'title', '__httpwww_opengis_netgml3_2_MultiPointPropertyType_httpwww_w3_org1999xlinktitle', _ImportedBinding_bindings_v1411_write__xlink.titleAttrType)
    __title._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 64, 1)
    __title._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 116, 2)
    
    title = property(__title.value, __title.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}show uses Python identifier show
    __show = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'show'), 'show', '__httpwww_opengis_netgml3_2_MultiPointPropertyType_httpwww_w3_org1999xlinkshow', _ImportedBinding_bindings_v1411_write__xlink.showType)
    __show._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 70, 1)
    __show._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 117, 2)
    
    show = property(__show.value, __show.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}actuate uses Python identifier actuate
    __actuate = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'actuate'), 'actuate', '__httpwww_opengis_netgml3_2_MultiPointPropertyType_httpwww_w3_org1999xlinkactuate', _ImportedBinding_bindings_v1411_write__xlink.actuateType)
    __actuate._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 82, 1)
    __actuate._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 118, 2)
    
    actuate = property(__actuate.value, __actuate.set, None, None)

    _ElementMap.update({
        __MultiPoint.name() : __MultiPoint
    })
    _AttributeMap.update({
        __remoteSchema.name() : __remoteSchema,
        __nilReason.name() : __nilReason,
        __owns.name() : __owns,
        __type.name() : __type,
        __href.name() : __href,
        __role.name() : __role,
        __arcrole.name() : __arcrole,
        __title.name() : __title,
        __show.name() : __show,
        __actuate.name() : __actuate
    })
_module_typeBindings.MultiPointPropertyType = MultiPointPropertyType
_Namespace_gml.addCategoryObject('typeBinding', 'MultiPointPropertyType', MultiPointPropertyType)


# Complex type {http://www.opengis.net/gml/3.2}MultiCurvePropertyType with content type ELEMENT_ONLY
class MultiCurvePropertyType (pyxb.binding.basis.complexTypeDefinition):
    """A property that has a collection of curves as its value domain may either be an appropriate geometry element encapsulated in an element of this type or an XLink reference to a remote geometry element (where remote includes geometry elements located elsewhere in the same document). Either the reference or the contained element shall be given, but neither both nor none."""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'MultiCurvePropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryAggregates.xsd', 120, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.opengis.net/gml/3.2}MultiCurve uses Python identifier MultiCurve
    __MultiCurve = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'MultiCurve'), 'MultiCurve', '__httpwww_opengis_netgml3_2_MultiCurvePropertyType_httpwww_opengis_netgml3_2MultiCurve', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryAggregates.xsd', 109, 1), )

    
    MultiCurve = property(__MultiCurve.value, __MultiCurve.set, None, 'A gml:MultiCurve is defined by one or more gml:AbstractCurves.\nThe members of the geometric aggregate may be specified either using the "standard" property (gml:curveMember) or the array property (gml:curveMembers). It is also valid to use both the "standard" and the array properties in the same collection.')

    
    # Attribute {http://www.opengis.net/gml/3.2}remoteSchema uses Python identifier remoteSchema
    __remoteSchema = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gml, 'remoteSchema'), 'remoteSchema', '__httpwww_opengis_netgml3_2_MultiCurvePropertyType_httpwww_opengis_netgml3_2remoteSchema', pyxb.binding.datatypes.anyURI)
    __remoteSchema._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 638, 1)
    __remoteSchema._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 52, 2)
    
    remoteSchema = property(__remoteSchema.value, __remoteSchema.set, None, '')

    
    # Attribute nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'nilReason'), 'nilReason', '__httpwww_opengis_netgml3_2_MultiCurvePropertyType_nilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 51, 2)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 51, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    
    # Attribute owns uses Python identifier owns
    __owns = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'owns'), 'owns', '__httpwww_opengis_netgml3_2_MultiCurvePropertyType_owns', pyxb.binding.datatypes.boolean, unicode_default='false')
    __owns._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 79, 2)
    __owns._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 79, 2)
    
    owns = property(__owns.value, __owns.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}type uses Python identifier type
    __type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'type'), 'type', '__httpwww_opengis_netgml3_2_MultiCurvePropertyType_httpwww_w3_org1999xlinktype', _ImportedBinding_bindings_v1411_write__xlink.typeType, fixed=True, unicode_default='simple')
    __type._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 29, 1)
    __type._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 112, 2)
    
    type = property(__type.value, __type.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}href uses Python identifier href
    __href = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'href'), 'href', '__httpwww_opengis_netgml3_2_MultiCurvePropertyType_httpwww_w3_org1999xlinkhref', _ImportedBinding_bindings_v1411_write__xlink.hrefType)
    __href._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 42, 1)
    __href._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 113, 2)
    
    href = property(__href.value, __href.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}role uses Python identifier role
    __role = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'role'), 'role', '__httpwww_opengis_netgml3_2_MultiCurvePropertyType_httpwww_w3_org1999xlinkrole', _ImportedBinding_bindings_v1411_write__xlink.roleType)
    __role._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 48, 1)
    __role._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 114, 2)
    
    role = property(__role.value, __role.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}arcrole uses Python identifier arcrole
    __arcrole = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'arcrole'), 'arcrole', '__httpwww_opengis_netgml3_2_MultiCurvePropertyType_httpwww_w3_org1999xlinkarcrole', _ImportedBinding_bindings_v1411_write__xlink.arcroleType)
    __arcrole._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 56, 1)
    __arcrole._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 115, 2)
    
    arcrole = property(__arcrole.value, __arcrole.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}title uses Python identifier title
    __title = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'title'), 'title', '__httpwww_opengis_netgml3_2_MultiCurvePropertyType_httpwww_w3_org1999xlinktitle', _ImportedBinding_bindings_v1411_write__xlink.titleAttrType)
    __title._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 64, 1)
    __title._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 116, 2)
    
    title = property(__title.value, __title.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}show uses Python identifier show
    __show = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'show'), 'show', '__httpwww_opengis_netgml3_2_MultiCurvePropertyType_httpwww_w3_org1999xlinkshow', _ImportedBinding_bindings_v1411_write__xlink.showType)
    __show._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 70, 1)
    __show._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 117, 2)
    
    show = property(__show.value, __show.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}actuate uses Python identifier actuate
    __actuate = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'actuate'), 'actuate', '__httpwww_opengis_netgml3_2_MultiCurvePropertyType_httpwww_w3_org1999xlinkactuate', _ImportedBinding_bindings_v1411_write__xlink.actuateType)
    __actuate._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 82, 1)
    __actuate._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 118, 2)
    
    actuate = property(__actuate.value, __actuate.set, None, None)

    _ElementMap.update({
        __MultiCurve.name() : __MultiCurve
    })
    _AttributeMap.update({
        __remoteSchema.name() : __remoteSchema,
        __nilReason.name() : __nilReason,
        __owns.name() : __owns,
        __type.name() : __type,
        __href.name() : __href,
        __role.name() : __role,
        __arcrole.name() : __arcrole,
        __title.name() : __title,
        __show.name() : __show,
        __actuate.name() : __actuate
    })
_module_typeBindings.MultiCurvePropertyType = MultiCurvePropertyType
_Namespace_gml.addCategoryObject('typeBinding', 'MultiCurvePropertyType', MultiCurvePropertyType)


# Complex type {http://www.opengis.net/gml/3.2}MultiSurfacePropertyType with content type ELEMENT_ONLY
class MultiSurfacePropertyType (pyxb.binding.basis.complexTypeDefinition):
    """A property that has a collection of surfaces as its value domain may either be an appropriate geometry element encapsulated in an element of this type or an XLink reference to a remote geometry element (where remote includes geometry elements located elsewhere in the same document). Either the reference or the contained element shall be given, but neither both nor none."""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'MultiSurfacePropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryAggregates.xsd', 151, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.opengis.net/gml/3.2}MultiSurface uses Python identifier MultiSurface
    __MultiSurface = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'MultiSurface'), 'MultiSurface', '__httpwww_opengis_netgml3_2_MultiSurfacePropertyType_httpwww_opengis_netgml3_2MultiSurface', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryAggregates.xsd', 140, 1), )

    
    MultiSurface = property(__MultiSurface.value, __MultiSurface.set, None, 'A gml:MultiSurface is defined by one or more gml:AbstractSurfaces.\nThe members of the geometric aggregate may be specified either using the "standard" property (gml:surfaceMember) or the array property (gml:surfaceMembers). It is also valid to use both the "standard" and the array properties in the same collection.')

    
    # Attribute {http://www.opengis.net/gml/3.2}remoteSchema uses Python identifier remoteSchema
    __remoteSchema = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gml, 'remoteSchema'), 'remoteSchema', '__httpwww_opengis_netgml3_2_MultiSurfacePropertyType_httpwww_opengis_netgml3_2remoteSchema', pyxb.binding.datatypes.anyURI)
    __remoteSchema._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 638, 1)
    __remoteSchema._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 52, 2)
    
    remoteSchema = property(__remoteSchema.value, __remoteSchema.set, None, '')

    
    # Attribute nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'nilReason'), 'nilReason', '__httpwww_opengis_netgml3_2_MultiSurfacePropertyType_nilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 51, 2)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 51, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    
    # Attribute owns uses Python identifier owns
    __owns = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'owns'), 'owns', '__httpwww_opengis_netgml3_2_MultiSurfacePropertyType_owns', pyxb.binding.datatypes.boolean, unicode_default='false')
    __owns._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 79, 2)
    __owns._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 79, 2)
    
    owns = property(__owns.value, __owns.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}type uses Python identifier type
    __type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'type'), 'type', '__httpwww_opengis_netgml3_2_MultiSurfacePropertyType_httpwww_w3_org1999xlinktype', _ImportedBinding_bindings_v1411_write__xlink.typeType, fixed=True, unicode_default='simple')
    __type._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 29, 1)
    __type._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 112, 2)
    
    type = property(__type.value, __type.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}href uses Python identifier href
    __href = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'href'), 'href', '__httpwww_opengis_netgml3_2_MultiSurfacePropertyType_httpwww_w3_org1999xlinkhref', _ImportedBinding_bindings_v1411_write__xlink.hrefType)
    __href._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 42, 1)
    __href._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 113, 2)
    
    href = property(__href.value, __href.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}role uses Python identifier role
    __role = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'role'), 'role', '__httpwww_opengis_netgml3_2_MultiSurfacePropertyType_httpwww_w3_org1999xlinkrole', _ImportedBinding_bindings_v1411_write__xlink.roleType)
    __role._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 48, 1)
    __role._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 114, 2)
    
    role = property(__role.value, __role.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}arcrole uses Python identifier arcrole
    __arcrole = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'arcrole'), 'arcrole', '__httpwww_opengis_netgml3_2_MultiSurfacePropertyType_httpwww_w3_org1999xlinkarcrole', _ImportedBinding_bindings_v1411_write__xlink.arcroleType)
    __arcrole._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 56, 1)
    __arcrole._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 115, 2)
    
    arcrole = property(__arcrole.value, __arcrole.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}title uses Python identifier title
    __title = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'title'), 'title', '__httpwww_opengis_netgml3_2_MultiSurfacePropertyType_httpwww_w3_org1999xlinktitle', _ImportedBinding_bindings_v1411_write__xlink.titleAttrType)
    __title._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 64, 1)
    __title._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 116, 2)
    
    title = property(__title.value, __title.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}show uses Python identifier show
    __show = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'show'), 'show', '__httpwww_opengis_netgml3_2_MultiSurfacePropertyType_httpwww_w3_org1999xlinkshow', _ImportedBinding_bindings_v1411_write__xlink.showType)
    __show._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 70, 1)
    __show._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 117, 2)
    
    show = property(__show.value, __show.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}actuate uses Python identifier actuate
    __actuate = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'actuate'), 'actuate', '__httpwww_opengis_netgml3_2_MultiSurfacePropertyType_httpwww_w3_org1999xlinkactuate', _ImportedBinding_bindings_v1411_write__xlink.actuateType)
    __actuate._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 82, 1)
    __actuate._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 118, 2)
    
    actuate = property(__actuate.value, __actuate.set, None, None)

    _ElementMap.update({
        __MultiSurface.name() : __MultiSurface
    })
    _AttributeMap.update({
        __remoteSchema.name() : __remoteSchema,
        __nilReason.name() : __nilReason,
        __owns.name() : __owns,
        __type.name() : __type,
        __href.name() : __href,
        __role.name() : __role,
        __arcrole.name() : __arcrole,
        __title.name() : __title,
        __show.name() : __show,
        __actuate.name() : __actuate
    })
_module_typeBindings.MultiSurfacePropertyType = MultiSurfacePropertyType
_Namespace_gml.addCategoryObject('typeBinding', 'MultiSurfacePropertyType', MultiSurfacePropertyType)


# Complex type {http://www.opengis.net/gml/3.2}MultiSolidPropertyType with content type ELEMENT_ONLY
class MultiSolidPropertyType (pyxb.binding.basis.complexTypeDefinition):
    """A property that has a collection of solids as its value domain may either be an appropriate geometry element encapsulated in an element of this type or an XLink reference to a remote geometry element (where remote includes geometry elements located elsewhere in the same document). Either the reference or the contained element shall be given, but neither both nor none."""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'MultiSolidPropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryAggregates.xsd', 187, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.opengis.net/gml/3.2}MultiSolid uses Python identifier MultiSolid
    __MultiSolid = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'MultiSolid'), 'MultiSolid', '__httpwww_opengis_netgml3_2_MultiSolidPropertyType_httpwww_opengis_netgml3_2MultiSolid', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryAggregates.xsd', 171, 1), )

    
    MultiSolid = property(__MultiSolid.value, __MultiSolid.set, None, 'A gml:MultiSolid is defined by one or more gml:AbstractSolids.\nThe members of the geometric aggregate may be specified either using the "standard" property (gml:solidMember) or the array property (gml:solidMembers). It is also valid to use both the "standard" and the array properties in the same collection.')

    
    # Attribute {http://www.opengis.net/gml/3.2}remoteSchema uses Python identifier remoteSchema
    __remoteSchema = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gml, 'remoteSchema'), 'remoteSchema', '__httpwww_opengis_netgml3_2_MultiSolidPropertyType_httpwww_opengis_netgml3_2remoteSchema', pyxb.binding.datatypes.anyURI)
    __remoteSchema._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 638, 1)
    __remoteSchema._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 52, 2)
    
    remoteSchema = property(__remoteSchema.value, __remoteSchema.set, None, '')

    
    # Attribute nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'nilReason'), 'nilReason', '__httpwww_opengis_netgml3_2_MultiSolidPropertyType_nilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 51, 2)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 51, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    
    # Attribute owns uses Python identifier owns
    __owns = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'owns'), 'owns', '__httpwww_opengis_netgml3_2_MultiSolidPropertyType_owns', pyxb.binding.datatypes.boolean, unicode_default='false')
    __owns._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 79, 2)
    __owns._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 79, 2)
    
    owns = property(__owns.value, __owns.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}type uses Python identifier type
    __type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'type'), 'type', '__httpwww_opengis_netgml3_2_MultiSolidPropertyType_httpwww_w3_org1999xlinktype', _ImportedBinding_bindings_v1411_write__xlink.typeType, fixed=True, unicode_default='simple')
    __type._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 29, 1)
    __type._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 112, 2)
    
    type = property(__type.value, __type.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}href uses Python identifier href
    __href = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'href'), 'href', '__httpwww_opengis_netgml3_2_MultiSolidPropertyType_httpwww_w3_org1999xlinkhref', _ImportedBinding_bindings_v1411_write__xlink.hrefType)
    __href._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 42, 1)
    __href._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 113, 2)
    
    href = property(__href.value, __href.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}role uses Python identifier role
    __role = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'role'), 'role', '__httpwww_opengis_netgml3_2_MultiSolidPropertyType_httpwww_w3_org1999xlinkrole', _ImportedBinding_bindings_v1411_write__xlink.roleType)
    __role._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 48, 1)
    __role._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 114, 2)
    
    role = property(__role.value, __role.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}arcrole uses Python identifier arcrole
    __arcrole = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'arcrole'), 'arcrole', '__httpwww_opengis_netgml3_2_MultiSolidPropertyType_httpwww_w3_org1999xlinkarcrole', _ImportedBinding_bindings_v1411_write__xlink.arcroleType)
    __arcrole._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 56, 1)
    __arcrole._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 115, 2)
    
    arcrole = property(__arcrole.value, __arcrole.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}title uses Python identifier title
    __title = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'title'), 'title', '__httpwww_opengis_netgml3_2_MultiSolidPropertyType_httpwww_w3_org1999xlinktitle', _ImportedBinding_bindings_v1411_write__xlink.titleAttrType)
    __title._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 64, 1)
    __title._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 116, 2)
    
    title = property(__title.value, __title.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}show uses Python identifier show
    __show = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'show'), 'show', '__httpwww_opengis_netgml3_2_MultiSolidPropertyType_httpwww_w3_org1999xlinkshow', _ImportedBinding_bindings_v1411_write__xlink.showType)
    __show._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 70, 1)
    __show._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 117, 2)
    
    show = property(__show.value, __show.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}actuate uses Python identifier actuate
    __actuate = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'actuate'), 'actuate', '__httpwww_opengis_netgml3_2_MultiSolidPropertyType_httpwww_w3_org1999xlinkactuate', _ImportedBinding_bindings_v1411_write__xlink.actuateType)
    __actuate._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 82, 1)
    __actuate._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 118, 2)
    
    actuate = property(__actuate.value, __actuate.set, None, None)

    _ElementMap.update({
        __MultiSolid.name() : __MultiSolid
    })
    _AttributeMap.update({
        __remoteSchema.name() : __remoteSchema,
        __nilReason.name() : __nilReason,
        __owns.name() : __owns,
        __type.name() : __type,
        __href.name() : __href,
        __role.name() : __role,
        __arcrole.name() : __arcrole,
        __title.name() : __title,
        __show.name() : __show,
        __actuate.name() : __actuate
    })
_module_typeBindings.MultiSolidPropertyType = MultiSolidPropertyType
_Namespace_gml.addCategoryObject('typeBinding', 'MultiSolidPropertyType', MultiSolidPropertyType)


# Complex type {http://www.opengis.net/gml/3.2}GeometryPropertyType with content type ELEMENT_ONLY
class GeometryPropertyType (pyxb.binding.basis.complexTypeDefinition):
    """A geometric property may either be any geometry element encapsulated in an element of this type or an XLink reference to a remote geometry element (where remote includes geometry elements located elsewhere in the same or another document). Note that either the reference or the contained element shall be given, but not both or none.
If a feature has a property that takes a geometry element as its value, this is called a geometry property. A generic type for such a geometry property is GeometryPropertyType."""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'GeometryPropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic0d1d.xsd', 55, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.opengis.net/gml/3.2}AbstractGeometry uses Python identifier AbstractGeometry
    __AbstractGeometry = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractGeometry'), 'AbstractGeometry', '__httpwww_opengis_netgml3_2_GeometryPropertyType_httpwww_opengis_netgml3_2AbstractGeometry', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic0d1d.xsd', 50, 1), )

    
    AbstractGeometry = property(__AbstractGeometry.value, __AbstractGeometry.set, None, 'The AbstractGeometry element is the abstract head of the substitution group for all geometry elements of GML. This includes pre-defined and user-defined geometry elements. Any geometry element shall be a direct or indirect extension/restriction of AbstractGeometryType and shall be directly or indirectly in the substitution group of AbstractGeometry.')

    
    # Attribute {http://www.opengis.net/gml/3.2}remoteSchema uses Python identifier remoteSchema
    __remoteSchema = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gml, 'remoteSchema'), 'remoteSchema', '__httpwww_opengis_netgml3_2_GeometryPropertyType_httpwww_opengis_netgml3_2remoteSchema', pyxb.binding.datatypes.anyURI)
    __remoteSchema._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 638, 1)
    __remoteSchema._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 52, 2)
    
    remoteSchema = property(__remoteSchema.value, __remoteSchema.set, None, '')

    
    # Attribute nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'nilReason'), 'nilReason', '__httpwww_opengis_netgml3_2_GeometryPropertyType_nilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 51, 2)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 51, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    
    # Attribute owns uses Python identifier owns
    __owns = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'owns'), 'owns', '__httpwww_opengis_netgml3_2_GeometryPropertyType_owns', pyxb.binding.datatypes.boolean, unicode_default='false')
    __owns._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 79, 2)
    __owns._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 79, 2)
    
    owns = property(__owns.value, __owns.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}type uses Python identifier type
    __type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'type'), 'type', '__httpwww_opengis_netgml3_2_GeometryPropertyType_httpwww_w3_org1999xlinktype', _ImportedBinding_bindings_v1411_write__xlink.typeType, fixed=True, unicode_default='simple')
    __type._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 29, 1)
    __type._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 112, 2)
    
    type = property(__type.value, __type.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}href uses Python identifier href
    __href = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'href'), 'href', '__httpwww_opengis_netgml3_2_GeometryPropertyType_httpwww_w3_org1999xlinkhref', _ImportedBinding_bindings_v1411_write__xlink.hrefType)
    __href._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 42, 1)
    __href._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 113, 2)
    
    href = property(__href.value, __href.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}role uses Python identifier role
    __role = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'role'), 'role', '__httpwww_opengis_netgml3_2_GeometryPropertyType_httpwww_w3_org1999xlinkrole', _ImportedBinding_bindings_v1411_write__xlink.roleType)
    __role._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 48, 1)
    __role._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 114, 2)
    
    role = property(__role.value, __role.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}arcrole uses Python identifier arcrole
    __arcrole = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'arcrole'), 'arcrole', '__httpwww_opengis_netgml3_2_GeometryPropertyType_httpwww_w3_org1999xlinkarcrole', _ImportedBinding_bindings_v1411_write__xlink.arcroleType)
    __arcrole._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 56, 1)
    __arcrole._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 115, 2)
    
    arcrole = property(__arcrole.value, __arcrole.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}title uses Python identifier title
    __title = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'title'), 'title', '__httpwww_opengis_netgml3_2_GeometryPropertyType_httpwww_w3_org1999xlinktitle', _ImportedBinding_bindings_v1411_write__xlink.titleAttrType)
    __title._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 64, 1)
    __title._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 116, 2)
    
    title = property(__title.value, __title.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}show uses Python identifier show
    __show = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'show'), 'show', '__httpwww_opengis_netgml3_2_GeometryPropertyType_httpwww_w3_org1999xlinkshow', _ImportedBinding_bindings_v1411_write__xlink.showType)
    __show._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 70, 1)
    __show._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 117, 2)
    
    show = property(__show.value, __show.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}actuate uses Python identifier actuate
    __actuate = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'actuate'), 'actuate', '__httpwww_opengis_netgml3_2_GeometryPropertyType_httpwww_w3_org1999xlinkactuate', _ImportedBinding_bindings_v1411_write__xlink.actuateType)
    __actuate._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 82, 1)
    __actuate._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 118, 2)
    
    actuate = property(__actuate.value, __actuate.set, None, None)

    _ElementMap.update({
        __AbstractGeometry.name() : __AbstractGeometry
    })
    _AttributeMap.update({
        __remoteSchema.name() : __remoteSchema,
        __nilReason.name() : __nilReason,
        __owns.name() : __owns,
        __type.name() : __type,
        __href.name() : __href,
        __role.name() : __role,
        __arcrole.name() : __arcrole,
        __title.name() : __title,
        __show.name() : __show,
        __actuate.name() : __actuate
    })
_module_typeBindings.GeometryPropertyType = GeometryPropertyType
_Namespace_gml.addCategoryObject('typeBinding', 'GeometryPropertyType', GeometryPropertyType)


# Complex type {http://www.opengis.net/gml/3.2}VectorType with content type SIMPLE
class VectorType (DirectPositionType):
    """For some applications the components of the position may be adjusted to yield a unit vector."""
    _TypeDefinition = STD_ANON_7
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_SIMPLE
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'VectorType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic0d1d.xsd', 124, 1)
    _ElementMap = DirectPositionType._ElementMap.copy()
    _AttributeMap = DirectPositionType._AttributeMap.copy()
    # Base type is DirectPositionType
    
    # Attribute srsName inherited from {http://www.opengis.net/gml/3.2}DirectPositionType
    
    # Attribute srsDimension inherited from {http://www.opengis.net/gml/3.2}DirectPositionType
    
    # Attribute axisLabels inherited from {http://www.opengis.net/gml/3.2}DirectPositionType
    
    # Attribute uomLabels inherited from {http://www.opengis.net/gml/3.2}DirectPositionType
    _ElementMap.update({
        
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.VectorType = VectorType
_Namespace_gml.addCategoryObject('typeBinding', 'VectorType', VectorType)


# Complex type {http://www.opengis.net/gml/3.2}AbstractGeometricPrimitiveType with content type ELEMENT_ONLY
class AbstractGeometricPrimitiveType (AbstractGeometryType):
    """gml:AbstractGeometricPrimitiveType is the abstract root type of the geometric primitives. A geometric primitive is a geometric object that is not decomposed further into other primitives in the system. All primitives are oriented in the direction implied by the sequence of their coordinate tuples."""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = True
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractGeometricPrimitiveType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic0d1d.xsd', 154, 1)
    _ElementMap = AbstractGeometryType._ElementMap.copy()
    _AttributeMap = AbstractGeometryType._AttributeMap.copy()
    # Base type is AbstractGeometryType
    
    # Element metaDataProperty ({http://www.opengis.net/gml/3.2}metaDataProperty) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element description ({http://www.opengis.net/gml/3.2}description) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element descriptionReference ({http://www.opengis.net/gml/3.2}descriptionReference) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element name ({http://www.opengis.net/gml/3.2}name) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element identifier ({http://www.opengis.net/gml/3.2}identifier) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Attribute srsName inherited from {http://www.opengis.net/gml/3.2}AbstractGeometryType
    
    # Attribute srsDimension inherited from {http://www.opengis.net/gml/3.2}AbstractGeometryType
    
    # Attribute axisLabels inherited from {http://www.opengis.net/gml/3.2}AbstractGeometryType
    
    # Attribute uomLabels inherited from {http://www.opengis.net/gml/3.2}AbstractGeometryType
    
    # Attribute id inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    _ElementMap.update({
        
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.AbstractGeometricPrimitiveType = AbstractGeometricPrimitiveType
_Namespace_gml.addCategoryObject('typeBinding', 'AbstractGeometricPrimitiveType', AbstractGeometricPrimitiveType)


# Complex type {http://www.opengis.net/gml/3.2}GeometricPrimitivePropertyType with content type ELEMENT_ONLY
class GeometricPrimitivePropertyType (pyxb.binding.basis.complexTypeDefinition):
    """A property that has a geometric primitive as its value domain may either be an appropriate geometry element encapsulated in an element of this type or an XLink reference to a remote geometry element (where remote includes geometry elements located elsewhere in the same document). Either the reference or the contained element shall be given, but neither both nor none."""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'GeometricPrimitivePropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic0d1d.xsd', 167, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.opengis.net/gml/3.2}AbstractGeometricPrimitive uses Python identifier AbstractGeometricPrimitive
    __AbstractGeometricPrimitive = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractGeometricPrimitive'), 'AbstractGeometricPrimitive', '__httpwww_opengis_netgml3_2_GeometricPrimitivePropertyType_httpwww_opengis_netgml3_2AbstractGeometricPrimitive', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic0d1d.xsd', 162, 1), )

    
    AbstractGeometricPrimitive = property(__AbstractGeometricPrimitive.value, __AbstractGeometricPrimitive.set, None, 'The AbstractGeometricPrimitive element is the abstract head of the substitution group for all (pre- and user-defined) geometric primitives.')

    
    # Attribute {http://www.opengis.net/gml/3.2}remoteSchema uses Python identifier remoteSchema
    __remoteSchema = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gml, 'remoteSchema'), 'remoteSchema', '__httpwww_opengis_netgml3_2_GeometricPrimitivePropertyType_httpwww_opengis_netgml3_2remoteSchema', pyxb.binding.datatypes.anyURI)
    __remoteSchema._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 638, 1)
    __remoteSchema._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 52, 2)
    
    remoteSchema = property(__remoteSchema.value, __remoteSchema.set, None, '')

    
    # Attribute nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'nilReason'), 'nilReason', '__httpwww_opengis_netgml3_2_GeometricPrimitivePropertyType_nilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 51, 2)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 51, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    
    # Attribute owns uses Python identifier owns
    __owns = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'owns'), 'owns', '__httpwww_opengis_netgml3_2_GeometricPrimitivePropertyType_owns', pyxb.binding.datatypes.boolean, unicode_default='false')
    __owns._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 79, 2)
    __owns._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 79, 2)
    
    owns = property(__owns.value, __owns.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}type uses Python identifier type
    __type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'type'), 'type', '__httpwww_opengis_netgml3_2_GeometricPrimitivePropertyType_httpwww_w3_org1999xlinktype', _ImportedBinding_bindings_v1411_write__xlink.typeType, fixed=True, unicode_default='simple')
    __type._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 29, 1)
    __type._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 112, 2)
    
    type = property(__type.value, __type.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}href uses Python identifier href
    __href = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'href'), 'href', '__httpwww_opengis_netgml3_2_GeometricPrimitivePropertyType_httpwww_w3_org1999xlinkhref', _ImportedBinding_bindings_v1411_write__xlink.hrefType)
    __href._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 42, 1)
    __href._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 113, 2)
    
    href = property(__href.value, __href.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}role uses Python identifier role
    __role = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'role'), 'role', '__httpwww_opengis_netgml3_2_GeometricPrimitivePropertyType_httpwww_w3_org1999xlinkrole', _ImportedBinding_bindings_v1411_write__xlink.roleType)
    __role._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 48, 1)
    __role._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 114, 2)
    
    role = property(__role.value, __role.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}arcrole uses Python identifier arcrole
    __arcrole = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'arcrole'), 'arcrole', '__httpwww_opengis_netgml3_2_GeometricPrimitivePropertyType_httpwww_w3_org1999xlinkarcrole', _ImportedBinding_bindings_v1411_write__xlink.arcroleType)
    __arcrole._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 56, 1)
    __arcrole._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 115, 2)
    
    arcrole = property(__arcrole.value, __arcrole.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}title uses Python identifier title
    __title = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'title'), 'title', '__httpwww_opengis_netgml3_2_GeometricPrimitivePropertyType_httpwww_w3_org1999xlinktitle', _ImportedBinding_bindings_v1411_write__xlink.titleAttrType)
    __title._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 64, 1)
    __title._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 116, 2)
    
    title = property(__title.value, __title.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}show uses Python identifier show
    __show = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'show'), 'show', '__httpwww_opengis_netgml3_2_GeometricPrimitivePropertyType_httpwww_w3_org1999xlinkshow', _ImportedBinding_bindings_v1411_write__xlink.showType)
    __show._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 70, 1)
    __show._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 117, 2)
    
    show = property(__show.value, __show.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}actuate uses Python identifier actuate
    __actuate = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'actuate'), 'actuate', '__httpwww_opengis_netgml3_2_GeometricPrimitivePropertyType_httpwww_w3_org1999xlinkactuate', _ImportedBinding_bindings_v1411_write__xlink.actuateType)
    __actuate._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 82, 1)
    __actuate._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 118, 2)
    
    actuate = property(__actuate.value, __actuate.set, None, None)

    _ElementMap.update({
        __AbstractGeometricPrimitive.name() : __AbstractGeometricPrimitive
    })
    _AttributeMap.update({
        __remoteSchema.name() : __remoteSchema,
        __nilReason.name() : __nilReason,
        __owns.name() : __owns,
        __type.name() : __type,
        __href.name() : __href,
        __role.name() : __role,
        __arcrole.name() : __arcrole,
        __title.name() : __title,
        __show.name() : __show,
        __actuate.name() : __actuate
    })
_module_typeBindings.GeometricPrimitivePropertyType = GeometricPrimitivePropertyType
_Namespace_gml.addCategoryObject('typeBinding', 'GeometricPrimitivePropertyType', GeometricPrimitivePropertyType)


# Complex type {http://www.opengis.net/gml/3.2}PointPropertyType with content type ELEMENT_ONLY
class PointPropertyType (pyxb.binding.basis.complexTypeDefinition):
    """A property that has a point as its value domain may either be an appropriate geometry element encapsulated in an element of this type or an XLink reference to a remote geometry element (where remote includes geometry elements located elsewhere in the same document). Either the reference or the contained element shall be given, but neither both nor none."""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'PointPropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic0d1d.xsd', 194, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.opengis.net/gml/3.2}Point uses Python identifier Point
    __Point = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'Point'), 'Point', '__httpwww_opengis_netgml3_2_PointPropertyType_httpwww_opengis_netgml3_2Point', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic0d1d.xsd', 189, 1), )

    
    Point = property(__Point.value, __Point.set, None, 'A Point is defined by a single coordinate tuple. The direct position of a point is specified by the pos element which is of type DirectPositionType.')

    
    # Attribute {http://www.opengis.net/gml/3.2}remoteSchema uses Python identifier remoteSchema
    __remoteSchema = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gml, 'remoteSchema'), 'remoteSchema', '__httpwww_opengis_netgml3_2_PointPropertyType_httpwww_opengis_netgml3_2remoteSchema', pyxb.binding.datatypes.anyURI)
    __remoteSchema._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 638, 1)
    __remoteSchema._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 52, 2)
    
    remoteSchema = property(__remoteSchema.value, __remoteSchema.set, None, '')

    
    # Attribute nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'nilReason'), 'nilReason', '__httpwww_opengis_netgml3_2_PointPropertyType_nilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 51, 2)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 51, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    
    # Attribute owns uses Python identifier owns
    __owns = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'owns'), 'owns', '__httpwww_opengis_netgml3_2_PointPropertyType_owns', pyxb.binding.datatypes.boolean, unicode_default='false')
    __owns._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 79, 2)
    __owns._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 79, 2)
    
    owns = property(__owns.value, __owns.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}type uses Python identifier type
    __type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'type'), 'type', '__httpwww_opengis_netgml3_2_PointPropertyType_httpwww_w3_org1999xlinktype', _ImportedBinding_bindings_v1411_write__xlink.typeType, fixed=True, unicode_default='simple')
    __type._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 29, 1)
    __type._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 112, 2)
    
    type = property(__type.value, __type.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}href uses Python identifier href
    __href = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'href'), 'href', '__httpwww_opengis_netgml3_2_PointPropertyType_httpwww_w3_org1999xlinkhref', _ImportedBinding_bindings_v1411_write__xlink.hrefType)
    __href._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 42, 1)
    __href._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 113, 2)
    
    href = property(__href.value, __href.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}role uses Python identifier role
    __role = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'role'), 'role', '__httpwww_opengis_netgml3_2_PointPropertyType_httpwww_w3_org1999xlinkrole', _ImportedBinding_bindings_v1411_write__xlink.roleType)
    __role._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 48, 1)
    __role._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 114, 2)
    
    role = property(__role.value, __role.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}arcrole uses Python identifier arcrole
    __arcrole = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'arcrole'), 'arcrole', '__httpwww_opengis_netgml3_2_PointPropertyType_httpwww_w3_org1999xlinkarcrole', _ImportedBinding_bindings_v1411_write__xlink.arcroleType)
    __arcrole._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 56, 1)
    __arcrole._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 115, 2)
    
    arcrole = property(__arcrole.value, __arcrole.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}title uses Python identifier title
    __title = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'title'), 'title', '__httpwww_opengis_netgml3_2_PointPropertyType_httpwww_w3_org1999xlinktitle', _ImportedBinding_bindings_v1411_write__xlink.titleAttrType)
    __title._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 64, 1)
    __title._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 116, 2)
    
    title = property(__title.value, __title.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}show uses Python identifier show
    __show = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'show'), 'show', '__httpwww_opengis_netgml3_2_PointPropertyType_httpwww_w3_org1999xlinkshow', _ImportedBinding_bindings_v1411_write__xlink.showType)
    __show._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 70, 1)
    __show._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 117, 2)
    
    show = property(__show.value, __show.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}actuate uses Python identifier actuate
    __actuate = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'actuate'), 'actuate', '__httpwww_opengis_netgml3_2_PointPropertyType_httpwww_w3_org1999xlinkactuate', _ImportedBinding_bindings_v1411_write__xlink.actuateType)
    __actuate._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 82, 1)
    __actuate._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 118, 2)
    
    actuate = property(__actuate.value, __actuate.set, None, None)

    _ElementMap.update({
        __Point.name() : __Point
    })
    _AttributeMap.update({
        __remoteSchema.name() : __remoteSchema,
        __nilReason.name() : __nilReason,
        __owns.name() : __owns,
        __type.name() : __type,
        __href.name() : __href,
        __role.name() : __role,
        __arcrole.name() : __arcrole,
        __title.name() : __title,
        __show.name() : __show,
        __actuate.name() : __actuate
    })
_module_typeBindings.PointPropertyType = PointPropertyType
_Namespace_gml.addCategoryObject('typeBinding', 'PointPropertyType', PointPropertyType)


# Complex type {http://www.opengis.net/gml/3.2}CurvePropertyType with content type ELEMENT_ONLY
class CurvePropertyType (pyxb.binding.basis.complexTypeDefinition):
    """A property that has a curve as its value domain may either be an appropriate geometry element encapsulated in an element of this type or an XLink reference to a remote geometry element (where remote includes geometry elements located elsewhere in the same document). Either the reference or the contained element shall be given, but neither both nor none."""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'CurvePropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic0d1d.xsd', 231, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.opengis.net/gml/3.2}AbstractCurve uses Python identifier AbstractCurve
    __AbstractCurve = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractCurve'), 'AbstractCurve', '__httpwww_opengis_netgml3_2_CurvePropertyType_httpwww_opengis_netgml3_2AbstractCurve', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic0d1d.xsd', 226, 1), )

    
    AbstractCurve = property(__AbstractCurve.value, __AbstractCurve.set, None, 'The AbstractCurve element is the abstract head of the substitution group for all (continuous) curve elements.')

    
    # Attribute {http://www.opengis.net/gml/3.2}remoteSchema uses Python identifier remoteSchema
    __remoteSchema = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gml, 'remoteSchema'), 'remoteSchema', '__httpwww_opengis_netgml3_2_CurvePropertyType_httpwww_opengis_netgml3_2remoteSchema', pyxb.binding.datatypes.anyURI)
    __remoteSchema._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 638, 1)
    __remoteSchema._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 52, 2)
    
    remoteSchema = property(__remoteSchema.value, __remoteSchema.set, None, '')

    
    # Attribute nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'nilReason'), 'nilReason', '__httpwww_opengis_netgml3_2_CurvePropertyType_nilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 51, 2)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 51, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    
    # Attribute owns uses Python identifier owns
    __owns = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'owns'), 'owns', '__httpwww_opengis_netgml3_2_CurvePropertyType_owns', pyxb.binding.datatypes.boolean, unicode_default='false')
    __owns._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 79, 2)
    __owns._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 79, 2)
    
    owns = property(__owns.value, __owns.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}type uses Python identifier type
    __type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'type'), 'type', '__httpwww_opengis_netgml3_2_CurvePropertyType_httpwww_w3_org1999xlinktype', _ImportedBinding_bindings_v1411_write__xlink.typeType, fixed=True, unicode_default='simple')
    __type._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 29, 1)
    __type._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 112, 2)
    
    type = property(__type.value, __type.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}href uses Python identifier href
    __href = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'href'), 'href', '__httpwww_opengis_netgml3_2_CurvePropertyType_httpwww_w3_org1999xlinkhref', _ImportedBinding_bindings_v1411_write__xlink.hrefType)
    __href._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 42, 1)
    __href._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 113, 2)
    
    href = property(__href.value, __href.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}role uses Python identifier role
    __role = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'role'), 'role', '__httpwww_opengis_netgml3_2_CurvePropertyType_httpwww_w3_org1999xlinkrole', _ImportedBinding_bindings_v1411_write__xlink.roleType)
    __role._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 48, 1)
    __role._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 114, 2)
    
    role = property(__role.value, __role.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}arcrole uses Python identifier arcrole
    __arcrole = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'arcrole'), 'arcrole', '__httpwww_opengis_netgml3_2_CurvePropertyType_httpwww_w3_org1999xlinkarcrole', _ImportedBinding_bindings_v1411_write__xlink.arcroleType)
    __arcrole._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 56, 1)
    __arcrole._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 115, 2)
    
    arcrole = property(__arcrole.value, __arcrole.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}title uses Python identifier title
    __title = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'title'), 'title', '__httpwww_opengis_netgml3_2_CurvePropertyType_httpwww_w3_org1999xlinktitle', _ImportedBinding_bindings_v1411_write__xlink.titleAttrType)
    __title._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 64, 1)
    __title._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 116, 2)
    
    title = property(__title.value, __title.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}show uses Python identifier show
    __show = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'show'), 'show', '__httpwww_opengis_netgml3_2_CurvePropertyType_httpwww_w3_org1999xlinkshow', _ImportedBinding_bindings_v1411_write__xlink.showType)
    __show._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 70, 1)
    __show._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 117, 2)
    
    show = property(__show.value, __show.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}actuate uses Python identifier actuate
    __actuate = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'actuate'), 'actuate', '__httpwww_opengis_netgml3_2_CurvePropertyType_httpwww_w3_org1999xlinkactuate', _ImportedBinding_bindings_v1411_write__xlink.actuateType)
    __actuate._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 82, 1)
    __actuate._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 118, 2)
    
    actuate = property(__actuate.value, __actuate.set, None, None)

    _ElementMap.update({
        __AbstractCurve.name() : __AbstractCurve
    })
    _AttributeMap.update({
        __remoteSchema.name() : __remoteSchema,
        __nilReason.name() : __nilReason,
        __owns.name() : __owns,
        __type.name() : __type,
        __href.name() : __href,
        __role.name() : __role,
        __arcrole.name() : __arcrole,
        __title.name() : __title,
        __show.name() : __show,
        __actuate.name() : __actuate
    })
_module_typeBindings.CurvePropertyType = CurvePropertyType
_Namespace_gml.addCategoryObject('typeBinding', 'CurvePropertyType', CurvePropertyType)


# Complex type {http://www.opengis.net/gml/3.2}SurfacePropertyType with content type ELEMENT_ONLY
class SurfacePropertyType (pyxb.binding.basis.complexTypeDefinition):
    """A property that has a surface as its value domain may either be an appropriate geometry element encapsulated in an element of this type or an XLink reference to a remote geometry element (where remote includes geometry elements located elsewhere in the same document). Either the reference or the contained element shall be given, but neither both nor none."""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'SurfacePropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic2d.xsd', 27, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.opengis.net/gml/3.2}AbstractSurface uses Python identifier AbstractSurface
    __AbstractSurface = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractSurface'), 'AbstractSurface', '__httpwww_opengis_netgml3_2_SurfacePropertyType_httpwww_opengis_netgml3_2AbstractSurface', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic2d.xsd', 22, 1), )

    
    AbstractSurface = property(__AbstractSurface.value, __AbstractSurface.set, None, 'The AbstractSurface element is the abstract head of the substitution group for all (continuous) surface elements.')

    
    # Attribute {http://www.opengis.net/gml/3.2}remoteSchema uses Python identifier remoteSchema
    __remoteSchema = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gml, 'remoteSchema'), 'remoteSchema', '__httpwww_opengis_netgml3_2_SurfacePropertyType_httpwww_opengis_netgml3_2remoteSchema', pyxb.binding.datatypes.anyURI)
    __remoteSchema._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 638, 1)
    __remoteSchema._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 52, 2)
    
    remoteSchema = property(__remoteSchema.value, __remoteSchema.set, None, '')

    
    # Attribute nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'nilReason'), 'nilReason', '__httpwww_opengis_netgml3_2_SurfacePropertyType_nilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 51, 2)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 51, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    
    # Attribute owns uses Python identifier owns
    __owns = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'owns'), 'owns', '__httpwww_opengis_netgml3_2_SurfacePropertyType_owns', pyxb.binding.datatypes.boolean, unicode_default='false')
    __owns._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 79, 2)
    __owns._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 79, 2)
    
    owns = property(__owns.value, __owns.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}type uses Python identifier type
    __type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'type'), 'type', '__httpwww_opengis_netgml3_2_SurfacePropertyType_httpwww_w3_org1999xlinktype', _ImportedBinding_bindings_v1411_write__xlink.typeType, fixed=True, unicode_default='simple')
    __type._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 29, 1)
    __type._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 112, 2)
    
    type = property(__type.value, __type.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}href uses Python identifier href
    __href = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'href'), 'href', '__httpwww_opengis_netgml3_2_SurfacePropertyType_httpwww_w3_org1999xlinkhref', _ImportedBinding_bindings_v1411_write__xlink.hrefType)
    __href._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 42, 1)
    __href._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 113, 2)
    
    href = property(__href.value, __href.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}role uses Python identifier role
    __role = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'role'), 'role', '__httpwww_opengis_netgml3_2_SurfacePropertyType_httpwww_w3_org1999xlinkrole', _ImportedBinding_bindings_v1411_write__xlink.roleType)
    __role._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 48, 1)
    __role._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 114, 2)
    
    role = property(__role.value, __role.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}arcrole uses Python identifier arcrole
    __arcrole = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'arcrole'), 'arcrole', '__httpwww_opengis_netgml3_2_SurfacePropertyType_httpwww_w3_org1999xlinkarcrole', _ImportedBinding_bindings_v1411_write__xlink.arcroleType)
    __arcrole._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 56, 1)
    __arcrole._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 115, 2)
    
    arcrole = property(__arcrole.value, __arcrole.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}title uses Python identifier title
    __title = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'title'), 'title', '__httpwww_opengis_netgml3_2_SurfacePropertyType_httpwww_w3_org1999xlinktitle', _ImportedBinding_bindings_v1411_write__xlink.titleAttrType)
    __title._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 64, 1)
    __title._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 116, 2)
    
    title = property(__title.value, __title.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}show uses Python identifier show
    __show = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'show'), 'show', '__httpwww_opengis_netgml3_2_SurfacePropertyType_httpwww_w3_org1999xlinkshow', _ImportedBinding_bindings_v1411_write__xlink.showType)
    __show._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 70, 1)
    __show._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 117, 2)
    
    show = property(__show.value, __show.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}actuate uses Python identifier actuate
    __actuate = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'actuate'), 'actuate', '__httpwww_opengis_netgml3_2_SurfacePropertyType_httpwww_w3_org1999xlinkactuate', _ImportedBinding_bindings_v1411_write__xlink.actuateType)
    __actuate._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 82, 1)
    __actuate._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 118, 2)
    
    actuate = property(__actuate.value, __actuate.set, None, None)

    _ElementMap.update({
        __AbstractSurface.name() : __AbstractSurface
    })
    _AttributeMap.update({
        __remoteSchema.name() : __remoteSchema,
        __nilReason.name() : __nilReason,
        __owns.name() : __owns,
        __type.name() : __type,
        __href.name() : __href,
        __role.name() : __role,
        __arcrole.name() : __arcrole,
        __title.name() : __title,
        __show.name() : __show,
        __actuate.name() : __actuate
    })
_module_typeBindings.SurfacePropertyType = SurfacePropertyType
_Namespace_gml.addCategoryObject('typeBinding', 'SurfacePropertyType', SurfacePropertyType)


# Complex type {http://www.opengis.net/gml/3.2}GeometricComplexType with content type ELEMENT_ONLY
class GeometricComplexType (AbstractGeometryType):
    """Complex type {http://www.opengis.net/gml/3.2}GeometricComplexType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'GeometricComplexType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryComplexes.xsd', 18, 1)
    _ElementMap = AbstractGeometryType._ElementMap.copy()
    _AttributeMap = AbstractGeometryType._AttributeMap.copy()
    # Base type is AbstractGeometryType
    
    # Element metaDataProperty ({http://www.opengis.net/gml/3.2}metaDataProperty) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element {http://www.opengis.net/gml/3.2}element uses Python identifier element
    __element = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'element'), 'element', '__httpwww_opengis_netgml3_2_GeometricComplexType_httpwww_opengis_netgml3_2element', True, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryComplexes.xsd', 22, 5), )

    
    element = property(__element.value, __element.set, None, None)

    
    # Element description ({http://www.opengis.net/gml/3.2}description) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element descriptionReference ({http://www.opengis.net/gml/3.2}descriptionReference) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element name ({http://www.opengis.net/gml/3.2}name) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element identifier ({http://www.opengis.net/gml/3.2}identifier) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Attribute srsName inherited from {http://www.opengis.net/gml/3.2}AbstractGeometryType
    
    # Attribute srsDimension inherited from {http://www.opengis.net/gml/3.2}AbstractGeometryType
    
    # Attribute axisLabels inherited from {http://www.opengis.net/gml/3.2}AbstractGeometryType
    
    # Attribute uomLabels inherited from {http://www.opengis.net/gml/3.2}AbstractGeometryType
    
    # Attribute id inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Attribute aggregationType uses Python identifier aggregationType
    __aggregationType = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'aggregationType'), 'aggregationType', '__httpwww_opengis_netgml3_2_GeometricComplexType_aggregationType', _module_typeBindings.AggregationType)
    __aggregationType._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 158, 2)
    __aggregationType._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 158, 2)
    
    aggregationType = property(__aggregationType.value, __aggregationType.set, None, None)

    _ElementMap.update({
        __element.name() : __element
    })
    _AttributeMap.update({
        __aggregationType.name() : __aggregationType
    })
_module_typeBindings.GeometricComplexType = GeometricComplexType
_Namespace_gml.addCategoryObject('typeBinding', 'GeometricComplexType', GeometricComplexType)


# Complex type {http://www.opengis.net/gml/3.2}GeometricComplexPropertyType with content type ELEMENT_ONLY
class GeometricComplexPropertyType (pyxb.binding.basis.complexTypeDefinition):
    """A property that has a geometric complex as its value domain may either be an appropriate geometry element encapsulated in an element of this type or an XLink reference to a remote geometry element (where remote includes geometry elements located elsewhere in the same document). Either the reference or the contained element shall be given, but neither both nor none."""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'GeometricComplexPropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryComplexes.xsd', 29, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.opengis.net/gml/3.2}GeometricComplex uses Python identifier GeometricComplex
    __GeometricComplex = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'GeometricComplex'), 'GeometricComplex', '__httpwww_opengis_netgml3_2_GeometricComplexPropertyType_httpwww_opengis_netgml3_2GeometricComplex', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryComplexes.xsd', 28, 1), )

    
    GeometricComplex = property(__GeometricComplex.value, __GeometricComplex.set, None, None)

    
    # Element {http://www.opengis.net/gml/3.2}CompositeCurve uses Python identifier CompositeCurve
    __CompositeCurve = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'CompositeCurve'), 'CompositeCurve', '__httpwww_opengis_netgml3_2_GeometricComplexPropertyType_httpwww_opengis_netgml3_2CompositeCurve', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryComplexes.xsd', 54, 1), )

    
    CompositeCurve = property(__CompositeCurve.value, __CompositeCurve.set, None, 'A gml:CompositeCurve is represented by a sequence of (orientable) curves such that each curve in the sequence terminates at the start point of the subsequent curve in the list. \ncurveMember references or contains inline one curve in the composite curve. \nThe curves are contiguous, the collection of curves is ordered. Therefore, if provided, the aggregationType attribute shall have the value "sequence".')

    
    # Element {http://www.opengis.net/gml/3.2}CompositeSurface uses Python identifier CompositeSurface
    __CompositeSurface = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'CompositeSurface'), 'CompositeSurface', '__httpwww_opengis_netgml3_2_GeometricComplexPropertyType_httpwww_opengis_netgml3_2CompositeSurface', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryComplexes.xsd', 71, 1), )

    
    CompositeSurface = property(__CompositeSurface.value, __CompositeSurface.set, None, 'A gml:CompositeSurface is represented by a set of orientable surfaces. It is geometry type with all the geometric properties of a (primitive) surface. Essentially, a composite surface is a collection of surfaces that join in pairs on common boundary curves and which, when considered as a whole, form a single surface.\nsurfaceMember references or contains inline one surface in the composite surface. \nThe surfaces are contiguous.')

    
    # Element {http://www.opengis.net/gml/3.2}CompositeSolid uses Python identifier CompositeSolid
    __CompositeSolid = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'CompositeSolid'), 'CompositeSolid', '__httpwww_opengis_netgml3_2_GeometricComplexPropertyType_httpwww_opengis_netgml3_2CompositeSolid', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryComplexes.xsd', 88, 1), )

    
    CompositeSolid = property(__CompositeSolid.value, __CompositeSolid.set, None, 'gml:CompositeSolid implements ISO 19107 GM_CompositeSolid (see ISO 19107:2003, 6.6.7) as specified in D.2.3.6. \nA gml:CompositeSolid is represented by a set of orientable surfaces. It is a geometry type with all the geometric properties of a (primitive) solid. Essentially, a composite solid is a collection of solids that join in pairs on common boundary surfaces and which, when considered as a whole, form a single solid. \nsolidMember references or contains one solid in the composite solid. The solids are contiguous.')

    
    # Attribute {http://www.opengis.net/gml/3.2}remoteSchema uses Python identifier remoteSchema
    __remoteSchema = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gml, 'remoteSchema'), 'remoteSchema', '__httpwww_opengis_netgml3_2_GeometricComplexPropertyType_httpwww_opengis_netgml3_2remoteSchema', pyxb.binding.datatypes.anyURI)
    __remoteSchema._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 638, 1)
    __remoteSchema._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 52, 2)
    
    remoteSchema = property(__remoteSchema.value, __remoteSchema.set, None, '')

    
    # Attribute nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'nilReason'), 'nilReason', '__httpwww_opengis_netgml3_2_GeometricComplexPropertyType_nilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 51, 2)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 51, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    
    # Attribute owns uses Python identifier owns
    __owns = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'owns'), 'owns', '__httpwww_opengis_netgml3_2_GeometricComplexPropertyType_owns', pyxb.binding.datatypes.boolean, unicode_default='false')
    __owns._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 79, 2)
    __owns._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 79, 2)
    
    owns = property(__owns.value, __owns.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}type uses Python identifier type
    __type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'type'), 'type', '__httpwww_opengis_netgml3_2_GeometricComplexPropertyType_httpwww_w3_org1999xlinktype', _ImportedBinding_bindings_v1411_write__xlink.typeType, fixed=True, unicode_default='simple')
    __type._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 29, 1)
    __type._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 112, 2)
    
    type = property(__type.value, __type.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}href uses Python identifier href
    __href = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'href'), 'href', '__httpwww_opengis_netgml3_2_GeometricComplexPropertyType_httpwww_w3_org1999xlinkhref', _ImportedBinding_bindings_v1411_write__xlink.hrefType)
    __href._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 42, 1)
    __href._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 113, 2)
    
    href = property(__href.value, __href.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}role uses Python identifier role
    __role = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'role'), 'role', '__httpwww_opengis_netgml3_2_GeometricComplexPropertyType_httpwww_w3_org1999xlinkrole', _ImportedBinding_bindings_v1411_write__xlink.roleType)
    __role._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 48, 1)
    __role._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 114, 2)
    
    role = property(__role.value, __role.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}arcrole uses Python identifier arcrole
    __arcrole = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'arcrole'), 'arcrole', '__httpwww_opengis_netgml3_2_GeometricComplexPropertyType_httpwww_w3_org1999xlinkarcrole', _ImportedBinding_bindings_v1411_write__xlink.arcroleType)
    __arcrole._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 56, 1)
    __arcrole._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 115, 2)
    
    arcrole = property(__arcrole.value, __arcrole.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}title uses Python identifier title
    __title = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'title'), 'title', '__httpwww_opengis_netgml3_2_GeometricComplexPropertyType_httpwww_w3_org1999xlinktitle', _ImportedBinding_bindings_v1411_write__xlink.titleAttrType)
    __title._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 64, 1)
    __title._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 116, 2)
    
    title = property(__title.value, __title.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}show uses Python identifier show
    __show = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'show'), 'show', '__httpwww_opengis_netgml3_2_GeometricComplexPropertyType_httpwww_w3_org1999xlinkshow', _ImportedBinding_bindings_v1411_write__xlink.showType)
    __show._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 70, 1)
    __show._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 117, 2)
    
    show = property(__show.value, __show.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}actuate uses Python identifier actuate
    __actuate = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'actuate'), 'actuate', '__httpwww_opengis_netgml3_2_GeometricComplexPropertyType_httpwww_w3_org1999xlinkactuate', _ImportedBinding_bindings_v1411_write__xlink.actuateType)
    __actuate._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 82, 1)
    __actuate._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 118, 2)
    
    actuate = property(__actuate.value, __actuate.set, None, None)

    _ElementMap.update({
        __GeometricComplex.name() : __GeometricComplex,
        __CompositeCurve.name() : __CompositeCurve,
        __CompositeSurface.name() : __CompositeSurface,
        __CompositeSolid.name() : __CompositeSolid
    })
    _AttributeMap.update({
        __remoteSchema.name() : __remoteSchema,
        __nilReason.name() : __nilReason,
        __owns.name() : __owns,
        __type.name() : __type,
        __href.name() : __href,
        __role.name() : __role,
        __arcrole.name() : __arcrole,
        __title.name() : __title,
        __show.name() : __show,
        __actuate.name() : __actuate
    })
_module_typeBindings.GeometricComplexPropertyType = GeometricComplexPropertyType
_Namespace_gml.addCategoryObject('typeBinding', 'GeometricComplexPropertyType', GeometricComplexPropertyType)


# Complex type {http://www.opengis.net/gml/3.2}ArcType with content type ELEMENT_ONLY
class ArcType (ArcStringType):
    """Complex type {http://www.opengis.net/gml/3.2}ArcType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'ArcType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 145, 1)
    _ElementMap = ArcStringType._ElementMap.copy()
    _AttributeMap = ArcStringType._AttributeMap.copy()
    # Base type is ArcStringType
    
    # Element coordinates ({http://www.opengis.net/gml/3.2}coordinates) inherited from {http://www.opengis.net/gml/3.2}ArcStringType
    
    # Element pointRep ({http://www.opengis.net/gml/3.2}pointRep) inherited from {http://www.opengis.net/gml/3.2}ArcStringType
    
    # Element pos ({http://www.opengis.net/gml/3.2}pos) inherited from {http://www.opengis.net/gml/3.2}ArcStringType
    
    # Element posList ({http://www.opengis.net/gml/3.2}posList) inherited from {http://www.opengis.net/gml/3.2}ArcStringType
    
    # Element pointProperty ({http://www.opengis.net/gml/3.2}pointProperty) inherited from {http://www.opengis.net/gml/3.2}ArcStringType
    
    # Attribute numDerivativesAtStart inherited from {http://www.opengis.net/gml/3.2}AbstractCurveSegmentType
    
    # Attribute numDerivativesAtEnd inherited from {http://www.opengis.net/gml/3.2}AbstractCurveSegmentType
    
    # Attribute numDerivativeInterior inherited from {http://www.opengis.net/gml/3.2}AbstractCurveSegmentType
    
    # Attribute interpolation inherited from {http://www.opengis.net/gml/3.2}ArcStringType
    
    # Attribute numArc is restricted from parent
    
    # Attribute numArc uses Python identifier numArc
    __numArc = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'numArc'), 'numArc', '__httpwww_opengis_netgml3_2_ArcStringType_numArc', pyxb.binding.datatypes.integer, fixed=True, unicode_default='1')
    __numArc._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 159, 4)
    __numArc._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 159, 4)
    
    numArc = property(__numArc.value, __numArc.set, None, None)

    _ElementMap.update({
        
    })
    _AttributeMap.update({
        __numArc.name() : __numArc
    })
_module_typeBindings.ArcType = ArcType
_Namespace_gml.addCategoryObject('typeBinding', 'ArcType', ArcType)


# Complex type {http://www.opengis.net/gml/3.2}ArcByBulgeType with content type ELEMENT_ONLY
class ArcByBulgeType (ArcStringByBulgeType):
    """Complex type {http://www.opengis.net/gml/3.2}ArcByBulgeType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'ArcByBulgeType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 207, 1)
    _ElementMap = ArcStringByBulgeType._ElementMap.copy()
    _AttributeMap = ArcStringByBulgeType._AttributeMap.copy()
    # Base type is ArcStringByBulgeType
    
    # Element coordinates ({http://www.opengis.net/gml/3.2}coordinates) inherited from {http://www.opengis.net/gml/3.2}ArcStringByBulgeType
    
    # Element pointRep ({http://www.opengis.net/gml/3.2}pointRep) inherited from {http://www.opengis.net/gml/3.2}ArcStringByBulgeType
    
    # Element pos ({http://www.opengis.net/gml/3.2}pos) inherited from {http://www.opengis.net/gml/3.2}ArcStringByBulgeType
    
    # Element posList ({http://www.opengis.net/gml/3.2}posList) inherited from {http://www.opengis.net/gml/3.2}ArcStringByBulgeType
    
    # Element pointProperty ({http://www.opengis.net/gml/3.2}pointProperty) inherited from {http://www.opengis.net/gml/3.2}ArcStringByBulgeType
    
    # Element bulge ({http://www.opengis.net/gml/3.2}bulge) inherited from {http://www.opengis.net/gml/3.2}ArcStringByBulgeType
    
    # Element normal ({http://www.opengis.net/gml/3.2}normal) inherited from {http://www.opengis.net/gml/3.2}ArcStringByBulgeType
    
    # Attribute numDerivativesAtStart inherited from {http://www.opengis.net/gml/3.2}AbstractCurveSegmentType
    
    # Attribute numDerivativesAtEnd inherited from {http://www.opengis.net/gml/3.2}AbstractCurveSegmentType
    
    # Attribute numDerivativeInterior inherited from {http://www.opengis.net/gml/3.2}AbstractCurveSegmentType
    
    # Attribute interpolation inherited from {http://www.opengis.net/gml/3.2}ArcStringByBulgeType
    
    # Attribute numArc is restricted from parent
    
    # Attribute numArc uses Python identifier numArc
    __numArc = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'numArc'), 'numArc', '__httpwww_opengis_netgml3_2_ArcStringByBulgeType_numArc', pyxb.binding.datatypes.integer, fixed=True, unicode_default='1')
    __numArc._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 223, 4)
    __numArc._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 223, 4)
    
    numArc = property(__numArc.value, __numArc.set, None, None)

    _ElementMap.update({
        
    })
    _AttributeMap.update({
        __numArc.name() : __numArc
    })
_module_typeBindings.ArcByBulgeType = ArcByBulgeType
_Namespace_gml.addCategoryObject('typeBinding', 'ArcByBulgeType', ArcByBulgeType)


# Complex type {http://www.opengis.net/gml/3.2}CircleByCenterPointType with content type ELEMENT_ONLY
class CircleByCenterPointType (ArcByCenterPointType):
    """Complex type {http://www.opengis.net/gml/3.2}CircleByCenterPointType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'CircleByCenterPointType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 266, 1)
    _ElementMap = ArcByCenterPointType._ElementMap.copy()
    _AttributeMap = ArcByCenterPointType._AttributeMap.copy()
    # Base type is ArcByCenterPointType
    
    # Element coordinates ({http://www.opengis.net/gml/3.2}coordinates) inherited from {http://www.opengis.net/gml/3.2}ArcByCenterPointType
    
    # Element pointRep ({http://www.opengis.net/gml/3.2}pointRep) inherited from {http://www.opengis.net/gml/3.2}ArcByCenterPointType
    
    # Element pos ({http://www.opengis.net/gml/3.2}pos) inherited from {http://www.opengis.net/gml/3.2}ArcByCenterPointType
    
    # Element posList ({http://www.opengis.net/gml/3.2}posList) inherited from {http://www.opengis.net/gml/3.2}ArcByCenterPointType
    
    # Element pointProperty ({http://www.opengis.net/gml/3.2}pointProperty) inherited from {http://www.opengis.net/gml/3.2}ArcByCenterPointType
    
    # Element radius ({http://www.opengis.net/gml/3.2}radius) inherited from {http://www.opengis.net/gml/3.2}ArcByCenterPointType
    
    # Attribute numDerivativesAtStart inherited from {http://www.opengis.net/gml/3.2}AbstractCurveSegmentType
    
    # Attribute numDerivativesAtEnd inherited from {http://www.opengis.net/gml/3.2}AbstractCurveSegmentType
    
    # Attribute numDerivativeInterior inherited from {http://www.opengis.net/gml/3.2}AbstractCurveSegmentType
    
    # Attribute interpolation inherited from {http://www.opengis.net/gml/3.2}ArcByCenterPointType
    
    # Attribute numArc inherited from {http://www.opengis.net/gml/3.2}ArcByCenterPointType
    _ElementMap.update({
        
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.CircleByCenterPointType = CircleByCenterPointType
_Namespace_gml.addCategoryObject('typeBinding', 'CircleByCenterPointType', CircleByCenterPointType)


# Complex type {http://www.opengis.net/gml/3.2}BezierType with content type ELEMENT_ONLY
class BezierType (BSplineType):
    """Complex type {http://www.opengis.net/gml/3.2}BezierType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'BezierType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 383, 1)
    _ElementMap = BSplineType._ElementMap.copy()
    _AttributeMap = BSplineType._AttributeMap.copy()
    # Base type is BSplineType
    
    # Element coordinates ({http://www.opengis.net/gml/3.2}coordinates) inherited from {http://www.opengis.net/gml/3.2}BSplineType
    
    # Element pointRep ({http://www.opengis.net/gml/3.2}pointRep) inherited from {http://www.opengis.net/gml/3.2}BSplineType
    
    # Element pos ({http://www.opengis.net/gml/3.2}pos) inherited from {http://www.opengis.net/gml/3.2}BSplineType
    
    # Element posList ({http://www.opengis.net/gml/3.2}posList) inherited from {http://www.opengis.net/gml/3.2}BSplineType
    
    # Element pointProperty ({http://www.opengis.net/gml/3.2}pointProperty) inherited from {http://www.opengis.net/gml/3.2}BSplineType
    
    # Element degree ({http://www.opengis.net/gml/3.2}degree) inherited from {http://www.opengis.net/gml/3.2}BSplineType
    
    # Element knot ({http://www.opengis.net/gml/3.2}knot) inherited from {http://www.opengis.net/gml/3.2}BSplineType
    
    # Attribute numDerivativesAtStart inherited from {http://www.opengis.net/gml/3.2}AbstractCurveSegmentType
    
    # Attribute numDerivativesAtEnd inherited from {http://www.opengis.net/gml/3.2}AbstractCurveSegmentType
    
    # Attribute numDerivativeInterior inherited from {http://www.opengis.net/gml/3.2}AbstractCurveSegmentType
    
    # Attribute interpolation is restricted from parent
    
    # Attribute interpolation uses Python identifier interpolation
    __interpolation = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'interpolation'), 'interpolation', '__httpwww_opengis_netgml3_2_BSplineType_interpolation', _module_typeBindings.CurveInterpolationType, fixed=True, unicode_default='polynomialSpline')
    __interpolation._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 399, 4)
    __interpolation._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 399, 4)
    
    interpolation = property(__interpolation.value, __interpolation.set, None, None)

    
    # Attribute isPolynomial is restricted from parent
    
    # Attribute isPolynomial uses Python identifier isPolynomial
    __isPolynomial = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'isPolynomial'), 'isPolynomial', '__httpwww_opengis_netgml3_2_BSplineType_isPolynomial', pyxb.binding.datatypes.boolean, fixed=True, unicode_default='true')
    __isPolynomial._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 400, 4)
    __isPolynomial._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 400, 4)
    
    isPolynomial = property(__isPolynomial.value, __isPolynomial.set, None, None)

    
    # Attribute knotType is restricted from parent
    
    # Attribute knotType uses Python identifier knotType
    __knotType = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'knotType'), 'knotType', '__httpwww_opengis_netgml3_2_BSplineType_knotType', _module_typeBindings.KnotTypesType, prohibited=True)
    __knotType._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 401, 4)
    __knotType._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 401, 4)
    
    knotType = property(__knotType.value, __knotType.set, None, None)

    _ElementMap.update({
        
    })
    _AttributeMap.update({
        __interpolation.name() : __interpolation,
        __isPolynomial.name() : __isPolynomial,
        __knotType.name() : __knotType
    })
_module_typeBindings.BezierType = BezierType
_Namespace_gml.addCategoryObject('typeBinding', 'BezierType', BezierType)


# Complex type {http://www.opengis.net/gml/3.2}GeodesicType with content type ELEMENT_ONLY
class GeodesicType (GeodesicStringType):
    """Complex type {http://www.opengis.net/gml/3.2}GeodesicType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'GeodesicType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 492, 1)
    _ElementMap = GeodesicStringType._ElementMap.copy()
    _AttributeMap = GeodesicStringType._AttributeMap.copy()
    # Base type is GeodesicStringType
    
    # Element pos ({http://www.opengis.net/gml/3.2}pos) inherited from {http://www.opengis.net/gml/3.2}GeodesicStringType
    
    # Element posList ({http://www.opengis.net/gml/3.2}posList) inherited from {http://www.opengis.net/gml/3.2}GeodesicStringType
    
    # Element pointProperty ({http://www.opengis.net/gml/3.2}pointProperty) inherited from {http://www.opengis.net/gml/3.2}GeodesicStringType
    
    # Attribute numDerivativesAtStart inherited from {http://www.opengis.net/gml/3.2}AbstractCurveSegmentType
    
    # Attribute numDerivativesAtEnd inherited from {http://www.opengis.net/gml/3.2}AbstractCurveSegmentType
    
    # Attribute numDerivativeInterior inherited from {http://www.opengis.net/gml/3.2}AbstractCurveSegmentType
    
    # Attribute interpolation inherited from {http://www.opengis.net/gml/3.2}GeodesicStringType
    _ElementMap.update({
        
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.GeodesicType = GeodesicType
_Namespace_gml.addCategoryObject('typeBinding', 'GeodesicType', GeodesicType)


# Complex type {http://www.opengis.net/gml/3.2}AbstractGriddedSurfaceType with content type ELEMENT_ONLY
class AbstractGriddedSurfaceType (AbstractParametricCurveSurfaceType):
    """Complex type {http://www.opengis.net/gml/3.2}AbstractGriddedSurfaceType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = True
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractGriddedSurfaceType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 679, 1)
    _ElementMap = AbstractParametricCurveSurfaceType._ElementMap.copy()
    _AttributeMap = AbstractParametricCurveSurfaceType._AttributeMap.copy()
    # Base type is AbstractParametricCurveSurfaceType
    
    # Element {http://www.opengis.net/gml/3.2}rows uses Python identifier rows
    __rows = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'rows'), 'rows', '__httpwww_opengis_netgml3_2_AbstractGriddedSurfaceType_httpwww_opengis_netgml3_2rows', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 653, 3), )

    
    rows = property(__rows.value, __rows.set, None, None)

    
    # Attribute rows uses Python identifier rows_
    __rows_ = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'rows'), 'rows_', '__httpwww_opengis_netgml3_2_AbstractGriddedSurfaceType_rows', pyxb.binding.datatypes.integer)
    __rows_._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 685, 4)
    __rows_._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 685, 4)
    
    rows_ = property(__rows_.value, __rows_.set, None, None)

    
    # Attribute columns uses Python identifier columns
    __columns = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'columns'), 'columns', '__httpwww_opengis_netgml3_2_AbstractGriddedSurfaceType_columns', pyxb.binding.datatypes.integer)
    __columns._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 686, 4)
    __columns._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 686, 4)
    
    columns = property(__columns.value, __columns.set, None, None)

    
    # Attribute aggregationType inherited from {http://www.opengis.net/gml/3.2}AbstractParametricCurveSurfaceType
    _ElementMap.update({
        __rows.name() : __rows
    })
    _AttributeMap.update({
        __rows_.name() : __rows_,
        __columns.name() : __columns
    })
_module_typeBindings.AbstractGriddedSurfaceType = AbstractGriddedSurfaceType
_Namespace_gml.addCategoryObject('typeBinding', 'AbstractGriddedSurfaceType', AbstractGriddedSurfaceType)


# Complex type {http://www.opengis.net/gml/3.2}SolidPropertyType with content type ELEMENT_ONLY
class SolidPropertyType (pyxb.binding.basis.complexTypeDefinition):
    """A property that has a solid as its value domain may either be an appropriate geometry element encapsulated in an element of this type or an XLink reference to a remote geometry element (where remote includes geometry elements located elsewhere in the same document). Either the reference or the contained element shall be given, but neither both nor none."""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'SolidPropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 780, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.opengis.net/gml/3.2}AbstractSolid uses Python identifier AbstractSolid
    __AbstractSolid = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractSolid'), 'AbstractSolid', '__httpwww_opengis_netgml3_2_SolidPropertyType_httpwww_opengis_netgml3_2AbstractSolid', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 775, 1), )

    
    AbstractSolid = property(__AbstractSolid.value, __AbstractSolid.set, None, 'The AbstractSolid element is the abstract head of the substituition group for all (continuous) solid elements.')

    
    # Attribute {http://www.opengis.net/gml/3.2}remoteSchema uses Python identifier remoteSchema
    __remoteSchema = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gml, 'remoteSchema'), 'remoteSchema', '__httpwww_opengis_netgml3_2_SolidPropertyType_httpwww_opengis_netgml3_2remoteSchema', pyxb.binding.datatypes.anyURI)
    __remoteSchema._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 638, 1)
    __remoteSchema._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 52, 2)
    
    remoteSchema = property(__remoteSchema.value, __remoteSchema.set, None, '')

    
    # Attribute nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'nilReason'), 'nilReason', '__httpwww_opengis_netgml3_2_SolidPropertyType_nilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 51, 2)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 51, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    
    # Attribute owns uses Python identifier owns
    __owns = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'owns'), 'owns', '__httpwww_opengis_netgml3_2_SolidPropertyType_owns', pyxb.binding.datatypes.boolean, unicode_default='false')
    __owns._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 79, 2)
    __owns._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 79, 2)
    
    owns = property(__owns.value, __owns.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}type uses Python identifier type
    __type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'type'), 'type', '__httpwww_opengis_netgml3_2_SolidPropertyType_httpwww_w3_org1999xlinktype', _ImportedBinding_bindings_v1411_write__xlink.typeType, fixed=True, unicode_default='simple')
    __type._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 29, 1)
    __type._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 112, 2)
    
    type = property(__type.value, __type.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}href uses Python identifier href
    __href = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'href'), 'href', '__httpwww_opengis_netgml3_2_SolidPropertyType_httpwww_w3_org1999xlinkhref', _ImportedBinding_bindings_v1411_write__xlink.hrefType)
    __href._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 42, 1)
    __href._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 113, 2)
    
    href = property(__href.value, __href.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}role uses Python identifier role
    __role = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'role'), 'role', '__httpwww_opengis_netgml3_2_SolidPropertyType_httpwww_w3_org1999xlinkrole', _ImportedBinding_bindings_v1411_write__xlink.roleType)
    __role._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 48, 1)
    __role._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 114, 2)
    
    role = property(__role.value, __role.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}arcrole uses Python identifier arcrole
    __arcrole = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'arcrole'), 'arcrole', '__httpwww_opengis_netgml3_2_SolidPropertyType_httpwww_w3_org1999xlinkarcrole', _ImportedBinding_bindings_v1411_write__xlink.arcroleType)
    __arcrole._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 56, 1)
    __arcrole._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 115, 2)
    
    arcrole = property(__arcrole.value, __arcrole.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}title uses Python identifier title
    __title = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'title'), 'title', '__httpwww_opengis_netgml3_2_SolidPropertyType_httpwww_w3_org1999xlinktitle', _ImportedBinding_bindings_v1411_write__xlink.titleAttrType)
    __title._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 64, 1)
    __title._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 116, 2)
    
    title = property(__title.value, __title.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}show uses Python identifier show
    __show = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'show'), 'show', '__httpwww_opengis_netgml3_2_SolidPropertyType_httpwww_w3_org1999xlinkshow', _ImportedBinding_bindings_v1411_write__xlink.showType)
    __show._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 70, 1)
    __show._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 117, 2)
    
    show = property(__show.value, __show.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}actuate uses Python identifier actuate
    __actuate = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'actuate'), 'actuate', '__httpwww_opengis_netgml3_2_SolidPropertyType_httpwww_w3_org1999xlinkactuate', _ImportedBinding_bindings_v1411_write__xlink.actuateType)
    __actuate._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 82, 1)
    __actuate._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 118, 2)
    
    actuate = property(__actuate.value, __actuate.set, None, None)

    _ElementMap.update({
        __AbstractSolid.name() : __AbstractSolid
    })
    _AttributeMap.update({
        __remoteSchema.name() : __remoteSchema,
        __nilReason.name() : __nilReason,
        __owns.name() : __owns,
        __type.name() : __type,
        __href.name() : __href,
        __role.name() : __role,
        __arcrole.name() : __arcrole,
        __title.name() : __title,
        __show.name() : __show,
        __actuate.name() : __actuate
    })
_module_typeBindings.SolidPropertyType = SolidPropertyType
_Namespace_gml.addCategoryObject('typeBinding', 'SolidPropertyType', SolidPropertyType)


# Complex type {http://www.opengis.net/gml/3.2}AssociationRoleType with content type ELEMENT_ONLY
class AssociationRoleType (pyxb.binding.basis.complexTypeDefinition):
    """Complex type {http://www.opengis.net/gml/3.2}AssociationRoleType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'AssociationRoleType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 67, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Attribute {http://www.opengis.net/gml/3.2}remoteSchema uses Python identifier remoteSchema
    __remoteSchema = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gml, 'remoteSchema'), 'remoteSchema', '__httpwww_opengis_netgml3_2_AssociationRoleType_httpwww_opengis_netgml3_2remoteSchema', pyxb.binding.datatypes.anyURI)
    __remoteSchema._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 638, 1)
    __remoteSchema._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 52, 2)
    
    remoteSchema = property(__remoteSchema.value, __remoteSchema.set, None, '')

    
    # Attribute nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'nilReason'), 'nilReason', '__httpwww_opengis_netgml3_2_AssociationRoleType_nilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 51, 2)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 51, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    
    # Attribute owns uses Python identifier owns
    __owns = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'owns'), 'owns', '__httpwww_opengis_netgml3_2_AssociationRoleType_owns', pyxb.binding.datatypes.boolean, unicode_default='false')
    __owns._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 79, 2)
    __owns._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 79, 2)
    
    owns = property(__owns.value, __owns.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}type uses Python identifier type
    __type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'type'), 'type', '__httpwww_opengis_netgml3_2_AssociationRoleType_httpwww_w3_org1999xlinktype', _ImportedBinding_bindings_v1411_write__xlink.typeType, fixed=True, unicode_default='simple')
    __type._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 29, 1)
    __type._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 112, 2)
    
    type = property(__type.value, __type.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}href uses Python identifier href
    __href = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'href'), 'href', '__httpwww_opengis_netgml3_2_AssociationRoleType_httpwww_w3_org1999xlinkhref', _ImportedBinding_bindings_v1411_write__xlink.hrefType)
    __href._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 42, 1)
    __href._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 113, 2)
    
    href = property(__href.value, __href.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}role uses Python identifier role
    __role = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'role'), 'role', '__httpwww_opengis_netgml3_2_AssociationRoleType_httpwww_w3_org1999xlinkrole', _ImportedBinding_bindings_v1411_write__xlink.roleType)
    __role._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 48, 1)
    __role._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 114, 2)
    
    role = property(__role.value, __role.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}arcrole uses Python identifier arcrole
    __arcrole = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'arcrole'), 'arcrole', '__httpwww_opengis_netgml3_2_AssociationRoleType_httpwww_w3_org1999xlinkarcrole', _ImportedBinding_bindings_v1411_write__xlink.arcroleType)
    __arcrole._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 56, 1)
    __arcrole._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 115, 2)
    
    arcrole = property(__arcrole.value, __arcrole.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}title uses Python identifier title
    __title = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'title'), 'title', '__httpwww_opengis_netgml3_2_AssociationRoleType_httpwww_w3_org1999xlinktitle', _ImportedBinding_bindings_v1411_write__xlink.titleAttrType)
    __title._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 64, 1)
    __title._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 116, 2)
    
    title = property(__title.value, __title.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}show uses Python identifier show
    __show = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'show'), 'show', '__httpwww_opengis_netgml3_2_AssociationRoleType_httpwww_w3_org1999xlinkshow', _ImportedBinding_bindings_v1411_write__xlink.showType)
    __show._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 70, 1)
    __show._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 117, 2)
    
    show = property(__show.value, __show.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}actuate uses Python identifier actuate
    __actuate = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'actuate'), 'actuate', '__httpwww_opengis_netgml3_2_AssociationRoleType_httpwww_w3_org1999xlinkactuate', _ImportedBinding_bindings_v1411_write__xlink.actuateType)
    __actuate._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 82, 1)
    __actuate._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 118, 2)
    
    actuate = property(__actuate.value, __actuate.set, None, None)

    _HasWildcardElement = True
    _ElementMap.update({
        
    })
    _AttributeMap.update({
        __remoteSchema.name() : __remoteSchema,
        __nilReason.name() : __nilReason,
        __owns.name() : __owns,
        __type.name() : __type,
        __href.name() : __href,
        __role.name() : __role,
        __arcrole.name() : __arcrole,
        __title.name() : __title,
        __show.name() : __show,
        __actuate.name() : __actuate
    })
_module_typeBindings.AssociationRoleType = AssociationRoleType
_Namespace_gml.addCategoryObject('typeBinding', 'AssociationRoleType', AssociationRoleType)


# Complex type {http://www.opengis.net/gml/3.2}ReferenceType with content type EMPTY
class ReferenceType (pyxb.binding.basis.complexTypeDefinition):
    """gml:ReferenceType is intended to be used in application schemas directly, if a property element shall use a "by-reference only" encoding."""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_EMPTY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'ReferenceType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 93, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Attribute {http://www.opengis.net/gml/3.2}remoteSchema uses Python identifier remoteSchema
    __remoteSchema = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gml, 'remoteSchema'), 'remoteSchema', '__httpwww_opengis_netgml3_2_ReferenceType_httpwww_opengis_netgml3_2remoteSchema', pyxb.binding.datatypes.anyURI)
    __remoteSchema._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 638, 1)
    __remoteSchema._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 52, 2)
    
    remoteSchema = property(__remoteSchema.value, __remoteSchema.set, None, '')

    
    # Attribute nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'nilReason'), 'nilReason', '__httpwww_opengis_netgml3_2_ReferenceType_nilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 51, 2)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 51, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    
    # Attribute owns uses Python identifier owns
    __owns = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'owns'), 'owns', '__httpwww_opengis_netgml3_2_ReferenceType_owns', pyxb.binding.datatypes.boolean, unicode_default='false')
    __owns._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 79, 2)
    __owns._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 79, 2)
    
    owns = property(__owns.value, __owns.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}type uses Python identifier type
    __type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'type'), 'type', '__httpwww_opengis_netgml3_2_ReferenceType_httpwww_w3_org1999xlinktype', _ImportedBinding_bindings_v1411_write__xlink.typeType, fixed=True, unicode_default='simple')
    __type._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 29, 1)
    __type._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 112, 2)
    
    type = property(__type.value, __type.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}href uses Python identifier href
    __href = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'href'), 'href', '__httpwww_opengis_netgml3_2_ReferenceType_httpwww_w3_org1999xlinkhref', _ImportedBinding_bindings_v1411_write__xlink.hrefType)
    __href._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 42, 1)
    __href._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 113, 2)
    
    href = property(__href.value, __href.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}role uses Python identifier role
    __role = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'role'), 'role', '__httpwww_opengis_netgml3_2_ReferenceType_httpwww_w3_org1999xlinkrole', _ImportedBinding_bindings_v1411_write__xlink.roleType)
    __role._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 48, 1)
    __role._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 114, 2)
    
    role = property(__role.value, __role.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}arcrole uses Python identifier arcrole
    __arcrole = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'arcrole'), 'arcrole', '__httpwww_opengis_netgml3_2_ReferenceType_httpwww_w3_org1999xlinkarcrole', _ImportedBinding_bindings_v1411_write__xlink.arcroleType)
    __arcrole._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 56, 1)
    __arcrole._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 115, 2)
    
    arcrole = property(__arcrole.value, __arcrole.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}title uses Python identifier title
    __title = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'title'), 'title', '__httpwww_opengis_netgml3_2_ReferenceType_httpwww_w3_org1999xlinktitle', _ImportedBinding_bindings_v1411_write__xlink.titleAttrType)
    __title._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 64, 1)
    __title._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 116, 2)
    
    title = property(__title.value, __title.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}show uses Python identifier show
    __show = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'show'), 'show', '__httpwww_opengis_netgml3_2_ReferenceType_httpwww_w3_org1999xlinkshow', _ImportedBinding_bindings_v1411_write__xlink.showType)
    __show._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 70, 1)
    __show._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 117, 2)
    
    show = property(__show.value, __show.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}actuate uses Python identifier actuate
    __actuate = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'actuate'), 'actuate', '__httpwww_opengis_netgml3_2_ReferenceType_httpwww_w3_org1999xlinkactuate', _ImportedBinding_bindings_v1411_write__xlink.actuateType)
    __actuate._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 82, 1)
    __actuate._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 118, 2)
    
    actuate = property(__actuate.value, __actuate.set, None, None)

    _ElementMap.update({
        
    })
    _AttributeMap.update({
        __remoteSchema.name() : __remoteSchema,
        __nilReason.name() : __nilReason,
        __owns.name() : __owns,
        __type.name() : __type,
        __href.name() : __href,
        __role.name() : __role,
        __arcrole.name() : __arcrole,
        __title.name() : __title,
        __show.name() : __show,
        __actuate.name() : __actuate
    })
_module_typeBindings.ReferenceType = ReferenceType
_Namespace_gml.addCategoryObject('typeBinding', 'ReferenceType', ReferenceType)


# Complex type {http://www.opengis.net/gml/3.2}GridType with content type ELEMENT_ONLY
class GridType (AbstractGeometryType):
    """Complex type {http://www.opengis.net/gml/3.2}GridType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'GridType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/grids.xsd', 23, 1)
    _ElementMap = AbstractGeometryType._ElementMap.copy()
    _AttributeMap = AbstractGeometryType._AttributeMap.copy()
    # Base type is AbstractGeometryType
    
    # Element metaDataProperty ({http://www.opengis.net/gml/3.2}metaDataProperty) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element description ({http://www.opengis.net/gml/3.2}description) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element descriptionReference ({http://www.opengis.net/gml/3.2}descriptionReference) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element name ({http://www.opengis.net/gml/3.2}name) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element identifier ({http://www.opengis.net/gml/3.2}identifier) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element {http://www.opengis.net/gml/3.2}limits uses Python identifier limits
    __limits = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'limits'), 'limits', '__httpwww_opengis_netgml3_2_GridType_httpwww_opengis_netgml3_2limits', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/grids.xsd', 27, 5), )

    
    limits = property(__limits.value, __limits.set, None, None)

    
    # Element {http://www.opengis.net/gml/3.2}axisLabels uses Python identifier axisLabels_
    __axisLabels_ = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'axisLabels'), 'axisLabels_', '__httpwww_opengis_netgml3_2_GridType_httpwww_opengis_netgml3_2axisLabels', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/grids.xsd', 29, 6), )

    
    axisLabels_ = property(__axisLabels_.value, __axisLabels_.set, None, None)

    
    # Element {http://www.opengis.net/gml/3.2}axisName uses Python identifier axisName
    __axisName = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'axisName'), 'axisName', '__httpwww_opengis_netgml3_2_GridType_httpwww_opengis_netgml3_2axisName', True, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/grids.xsd', 30, 6), )

    
    axisName = property(__axisName.value, __axisName.set, None, None)

    
    # Attribute srsName inherited from {http://www.opengis.net/gml/3.2}AbstractGeometryType
    
    # Attribute srsDimension inherited from {http://www.opengis.net/gml/3.2}AbstractGeometryType
    
    # Attribute axisLabels inherited from {http://www.opengis.net/gml/3.2}AbstractGeometryType
    
    # Attribute uomLabels inherited from {http://www.opengis.net/gml/3.2}AbstractGeometryType
    
    # Attribute id inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Attribute dimension uses Python identifier dimension
    __dimension = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'dimension'), 'dimension', '__httpwww_opengis_netgml3_2_GridType_dimension', pyxb.binding.datatypes.positiveInteger, required=True)
    __dimension._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/grids.xsd', 33, 4)
    __dimension._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/grids.xsd', 33, 4)
    
    dimension = property(__dimension.value, __dimension.set, None, None)

    _ElementMap.update({
        __limits.name() : __limits,
        __axisLabels_.name() : __axisLabels_,
        __axisName.name() : __axisName
    })
    _AttributeMap.update({
        __dimension.name() : __dimension
    })
_module_typeBindings.GridType = GridType
_Namespace_gml.addCategoryObject('typeBinding', 'GridType', GridType)


# Complex type {http://www.opengis.net/gml/3.2}ObservationType with content type ELEMENT_ONLY
class ObservationType (AbstractFeatureType):
    """Complex type {http://www.opengis.net/gml/3.2}ObservationType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'ObservationType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/observation.xsd', 29, 1)
    _ElementMap = AbstractFeatureType._ElementMap.copy()
    _AttributeMap = AbstractFeatureType._AttributeMap.copy()
    # Base type is AbstractFeatureType
    
    # Element metaDataProperty ({http://www.opengis.net/gml/3.2}metaDataProperty) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element location ({http://www.opengis.net/gml/3.2}location) inherited from {http://www.opengis.net/gml/3.2}AbstractFeatureType
    
    # Element boundedBy ({http://www.opengis.net/gml/3.2}boundedBy) inherited from {http://www.opengis.net/gml/3.2}AbstractFeatureType
    
    # Element description ({http://www.opengis.net/gml/3.2}description) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element descriptionReference ({http://www.opengis.net/gml/3.2}descriptionReference) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element name ({http://www.opengis.net/gml/3.2}name) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element identifier ({http://www.opengis.net/gml/3.2}identifier) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element {http://www.opengis.net/gml/3.2}using uses Python identifier using
    __using = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'using'), 'using', '__httpwww_opengis_netgml3_2_ObservationType_httpwww_opengis_netgml3_2using', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/observation.xsd', 41, 1), )

    
    using = property(__using.value, __using.set, None, None)

    
    # Element {http://www.opengis.net/gml/3.2}target uses Python identifier target
    __target = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'target'), 'target', '__httpwww_opengis_netgml3_2_ObservationType_httpwww_opengis_netgml3_2target', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/observation.xsd', 49, 1), )

    
    target = property(__target.value, __target.set, None, None)

    
    # Element {http://www.opengis.net/gml/3.2}resultOf uses Python identifier resultOf
    __resultOf = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'resultOf'), 'resultOf', '__httpwww_opengis_netgml3_2_ObservationType_httpwww_opengis_netgml3_2resultOf', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/observation.xsd', 59, 1), )

    
    resultOf = property(__resultOf.value, __resultOf.set, None, None)

    
    # Element {http://www.opengis.net/gml/3.2}validTime uses Python identifier validTime
    __validTime = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'validTime'), 'validTime', '__httpwww_opengis_netgml3_2_ObservationType_httpwww_opengis_netgml3_2validTime', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporal.xsd', 52, 1), )

    
    validTime = property(__validTime.value, __validTime.set, None, 'gml:validTime is a convenience property element.')

    
    # Attribute id inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    _ElementMap.update({
        __using.name() : __using,
        __target.name() : __target,
        __resultOf.name() : __resultOf,
        __validTime.name() : __validTime
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.ObservationType = ObservationType
_Namespace_gml.addCategoryObject('typeBinding', 'ObservationType', ObservationType)


# Complex type {http://www.opengis.net/gml/3.2}ProcedurePropertyType with content type ELEMENT_ONLY
class ProcedurePropertyType (pyxb.binding.basis.complexTypeDefinition):
    """Complex type {http://www.opengis.net/gml/3.2}ProcedurePropertyType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'ProcedurePropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/observation.xsd', 42, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.opengis.net/gml/3.2}AbstractFeature uses Python identifier AbstractFeature
    __AbstractFeature = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractFeature'), 'AbstractFeature', '__httpwww_opengis_netgml3_2_ProcedurePropertyType_httpwww_opengis_netgml3_2AbstractFeature', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/feature.xsd', 32, 1), )

    
    AbstractFeature = property(__AbstractFeature.value, __AbstractFeature.set, None, 'This abstract element serves as the head of a substitution group which may contain any elements whose content model is derived from gml:AbstractFeatureType.  This may be used as a variable in the construction of content models.  \ngml:AbstractFeature may be thought of as "anything that is a GML feature" and may be used to define variables or templates in which the value of a GML property is "any feature". This occurs in particular in a GML feature collection where the feature member properties contain one or multiple copies of gml:AbstractFeature respectively.')

    
    # Attribute {http://www.opengis.net/gml/3.2}remoteSchema uses Python identifier remoteSchema
    __remoteSchema = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gml, 'remoteSchema'), 'remoteSchema', '__httpwww_opengis_netgml3_2_ProcedurePropertyType_httpwww_opengis_netgml3_2remoteSchema', pyxb.binding.datatypes.anyURI)
    __remoteSchema._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 638, 1)
    __remoteSchema._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 52, 2)
    
    remoteSchema = property(__remoteSchema.value, __remoteSchema.set, None, '')

    
    # Attribute nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'nilReason'), 'nilReason', '__httpwww_opengis_netgml3_2_ProcedurePropertyType_nilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 51, 2)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 51, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    
    # Attribute owns uses Python identifier owns
    __owns = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'owns'), 'owns', '__httpwww_opengis_netgml3_2_ProcedurePropertyType_owns', pyxb.binding.datatypes.boolean, unicode_default='false')
    __owns._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 79, 2)
    __owns._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 79, 2)
    
    owns = property(__owns.value, __owns.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}type uses Python identifier type
    __type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'type'), 'type', '__httpwww_opengis_netgml3_2_ProcedurePropertyType_httpwww_w3_org1999xlinktype', _ImportedBinding_bindings_v1411_write__xlink.typeType, fixed=True, unicode_default='simple')
    __type._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 29, 1)
    __type._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 112, 2)
    
    type = property(__type.value, __type.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}href uses Python identifier href
    __href = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'href'), 'href', '__httpwww_opengis_netgml3_2_ProcedurePropertyType_httpwww_w3_org1999xlinkhref', _ImportedBinding_bindings_v1411_write__xlink.hrefType)
    __href._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 42, 1)
    __href._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 113, 2)
    
    href = property(__href.value, __href.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}role uses Python identifier role
    __role = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'role'), 'role', '__httpwww_opengis_netgml3_2_ProcedurePropertyType_httpwww_w3_org1999xlinkrole', _ImportedBinding_bindings_v1411_write__xlink.roleType)
    __role._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 48, 1)
    __role._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 114, 2)
    
    role = property(__role.value, __role.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}arcrole uses Python identifier arcrole
    __arcrole = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'arcrole'), 'arcrole', '__httpwww_opengis_netgml3_2_ProcedurePropertyType_httpwww_w3_org1999xlinkarcrole', _ImportedBinding_bindings_v1411_write__xlink.arcroleType)
    __arcrole._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 56, 1)
    __arcrole._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 115, 2)
    
    arcrole = property(__arcrole.value, __arcrole.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}title uses Python identifier title
    __title = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'title'), 'title', '__httpwww_opengis_netgml3_2_ProcedurePropertyType_httpwww_w3_org1999xlinktitle', _ImportedBinding_bindings_v1411_write__xlink.titleAttrType)
    __title._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 64, 1)
    __title._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 116, 2)
    
    title = property(__title.value, __title.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}show uses Python identifier show
    __show = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'show'), 'show', '__httpwww_opengis_netgml3_2_ProcedurePropertyType_httpwww_w3_org1999xlinkshow', _ImportedBinding_bindings_v1411_write__xlink.showType)
    __show._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 70, 1)
    __show._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 117, 2)
    
    show = property(__show.value, __show.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}actuate uses Python identifier actuate
    __actuate = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'actuate'), 'actuate', '__httpwww_opengis_netgml3_2_ProcedurePropertyType_httpwww_w3_org1999xlinkactuate', _ImportedBinding_bindings_v1411_write__xlink.actuateType)
    __actuate._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 82, 1)
    __actuate._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 118, 2)
    
    actuate = property(__actuate.value, __actuate.set, None, None)

    _ElementMap.update({
        __AbstractFeature.name() : __AbstractFeature
    })
    _AttributeMap.update({
        __remoteSchema.name() : __remoteSchema,
        __nilReason.name() : __nilReason,
        __owns.name() : __owns,
        __type.name() : __type,
        __href.name() : __href,
        __role.name() : __role,
        __arcrole.name() : __arcrole,
        __title.name() : __title,
        __show.name() : __show,
        __actuate.name() : __actuate
    })
_module_typeBindings.ProcedurePropertyType = ProcedurePropertyType
_Namespace_gml.addCategoryObject('typeBinding', 'ProcedurePropertyType', ProcedurePropertyType)


# Complex type {http://www.opengis.net/gml/3.2}TargetPropertyType with content type ELEMENT_ONLY
class TargetPropertyType (pyxb.binding.basis.complexTypeDefinition):
    """Complex type {http://www.opengis.net/gml/3.2}TargetPropertyType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'TargetPropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/observation.xsd', 51, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.opengis.net/gml/3.2}AbstractFeature uses Python identifier AbstractFeature
    __AbstractFeature = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractFeature'), 'AbstractFeature', '__httpwww_opengis_netgml3_2_TargetPropertyType_httpwww_opengis_netgml3_2AbstractFeature', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/feature.xsd', 32, 1), )

    
    AbstractFeature = property(__AbstractFeature.value, __AbstractFeature.set, None, 'This abstract element serves as the head of a substitution group which may contain any elements whose content model is derived from gml:AbstractFeatureType.  This may be used as a variable in the construction of content models.  \ngml:AbstractFeature may be thought of as "anything that is a GML feature" and may be used to define variables or templates in which the value of a GML property is "any feature". This occurs in particular in a GML feature collection where the feature member properties contain one or multiple copies of gml:AbstractFeature respectively.')

    
    # Element {http://www.opengis.net/gml/3.2}AbstractGeometry uses Python identifier AbstractGeometry
    __AbstractGeometry = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractGeometry'), 'AbstractGeometry', '__httpwww_opengis_netgml3_2_TargetPropertyType_httpwww_opengis_netgml3_2AbstractGeometry', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic0d1d.xsd', 50, 1), )

    
    AbstractGeometry = property(__AbstractGeometry.value, __AbstractGeometry.set, None, 'The AbstractGeometry element is the abstract head of the substitution group for all geometry elements of GML. This includes pre-defined and user-defined geometry elements. Any geometry element shall be a direct or indirect extension/restriction of AbstractGeometryType and shall be directly or indirectly in the substitution group of AbstractGeometry.')

    
    # Attribute {http://www.opengis.net/gml/3.2}remoteSchema uses Python identifier remoteSchema
    __remoteSchema = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gml, 'remoteSchema'), 'remoteSchema', '__httpwww_opengis_netgml3_2_TargetPropertyType_httpwww_opengis_netgml3_2remoteSchema', pyxb.binding.datatypes.anyURI)
    __remoteSchema._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 638, 1)
    __remoteSchema._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 52, 2)
    
    remoteSchema = property(__remoteSchema.value, __remoteSchema.set, None, '')

    
    # Attribute nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'nilReason'), 'nilReason', '__httpwww_opengis_netgml3_2_TargetPropertyType_nilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 51, 2)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 51, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    
    # Attribute owns uses Python identifier owns
    __owns = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'owns'), 'owns', '__httpwww_opengis_netgml3_2_TargetPropertyType_owns', pyxb.binding.datatypes.boolean, unicode_default='false')
    __owns._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 79, 2)
    __owns._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 79, 2)
    
    owns = property(__owns.value, __owns.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}type uses Python identifier type
    __type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'type'), 'type', '__httpwww_opengis_netgml3_2_TargetPropertyType_httpwww_w3_org1999xlinktype', _ImportedBinding_bindings_v1411_write__xlink.typeType, fixed=True, unicode_default='simple')
    __type._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 29, 1)
    __type._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 112, 2)
    
    type = property(__type.value, __type.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}href uses Python identifier href
    __href = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'href'), 'href', '__httpwww_opengis_netgml3_2_TargetPropertyType_httpwww_w3_org1999xlinkhref', _ImportedBinding_bindings_v1411_write__xlink.hrefType)
    __href._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 42, 1)
    __href._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 113, 2)
    
    href = property(__href.value, __href.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}role uses Python identifier role
    __role = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'role'), 'role', '__httpwww_opengis_netgml3_2_TargetPropertyType_httpwww_w3_org1999xlinkrole', _ImportedBinding_bindings_v1411_write__xlink.roleType)
    __role._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 48, 1)
    __role._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 114, 2)
    
    role = property(__role.value, __role.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}arcrole uses Python identifier arcrole
    __arcrole = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'arcrole'), 'arcrole', '__httpwww_opengis_netgml3_2_TargetPropertyType_httpwww_w3_org1999xlinkarcrole', _ImportedBinding_bindings_v1411_write__xlink.arcroleType)
    __arcrole._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 56, 1)
    __arcrole._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 115, 2)
    
    arcrole = property(__arcrole.value, __arcrole.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}title uses Python identifier title
    __title = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'title'), 'title', '__httpwww_opengis_netgml3_2_TargetPropertyType_httpwww_w3_org1999xlinktitle', _ImportedBinding_bindings_v1411_write__xlink.titleAttrType)
    __title._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 64, 1)
    __title._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 116, 2)
    
    title = property(__title.value, __title.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}show uses Python identifier show
    __show = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'show'), 'show', '__httpwww_opengis_netgml3_2_TargetPropertyType_httpwww_w3_org1999xlinkshow', _ImportedBinding_bindings_v1411_write__xlink.showType)
    __show._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 70, 1)
    __show._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 117, 2)
    
    show = property(__show.value, __show.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}actuate uses Python identifier actuate
    __actuate = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'actuate'), 'actuate', '__httpwww_opengis_netgml3_2_TargetPropertyType_httpwww_w3_org1999xlinkactuate', _ImportedBinding_bindings_v1411_write__xlink.actuateType)
    __actuate._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 82, 1)
    __actuate._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 118, 2)
    
    actuate = property(__actuate.value, __actuate.set, None, None)

    _ElementMap.update({
        __AbstractFeature.name() : __AbstractFeature,
        __AbstractGeometry.name() : __AbstractGeometry
    })
    _AttributeMap.update({
        __remoteSchema.name() : __remoteSchema,
        __nilReason.name() : __nilReason,
        __owns.name() : __owns,
        __type.name() : __type,
        __href.name() : __href,
        __role.name() : __role,
        __arcrole.name() : __arcrole,
        __title.name() : __title,
        __show.name() : __show,
        __actuate.name() : __actuate
    })
_module_typeBindings.TargetPropertyType = TargetPropertyType
_Namespace_gml.addCategoryObject('typeBinding', 'TargetPropertyType', TargetPropertyType)


# Complex type {http://www.opengis.net/gml/3.2}ResultType with content type ELEMENT_ONLY
class ResultType (pyxb.binding.basis.complexTypeDefinition):
    """Complex type {http://www.opengis.net/gml/3.2}ResultType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'ResultType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/observation.xsd', 60, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Attribute {http://www.opengis.net/gml/3.2}remoteSchema uses Python identifier remoteSchema
    __remoteSchema = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gml, 'remoteSchema'), 'remoteSchema', '__httpwww_opengis_netgml3_2_ResultType_httpwww_opengis_netgml3_2remoteSchema', pyxb.binding.datatypes.anyURI)
    __remoteSchema._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 638, 1)
    __remoteSchema._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 52, 2)
    
    remoteSchema = property(__remoteSchema.value, __remoteSchema.set, None, '')

    
    # Attribute nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'nilReason'), 'nilReason', '__httpwww_opengis_netgml3_2_ResultType_nilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 51, 2)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 51, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    
    # Attribute owns uses Python identifier owns
    __owns = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'owns'), 'owns', '__httpwww_opengis_netgml3_2_ResultType_owns', pyxb.binding.datatypes.boolean, unicode_default='false')
    __owns._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 79, 2)
    __owns._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 79, 2)
    
    owns = property(__owns.value, __owns.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}type uses Python identifier type
    __type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'type'), 'type', '__httpwww_opengis_netgml3_2_ResultType_httpwww_w3_org1999xlinktype', _ImportedBinding_bindings_v1411_write__xlink.typeType, fixed=True, unicode_default='simple')
    __type._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 29, 1)
    __type._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 112, 2)
    
    type = property(__type.value, __type.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}href uses Python identifier href
    __href = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'href'), 'href', '__httpwww_opengis_netgml3_2_ResultType_httpwww_w3_org1999xlinkhref', _ImportedBinding_bindings_v1411_write__xlink.hrefType)
    __href._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 42, 1)
    __href._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 113, 2)
    
    href = property(__href.value, __href.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}role uses Python identifier role
    __role = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'role'), 'role', '__httpwww_opengis_netgml3_2_ResultType_httpwww_w3_org1999xlinkrole', _ImportedBinding_bindings_v1411_write__xlink.roleType)
    __role._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 48, 1)
    __role._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 114, 2)
    
    role = property(__role.value, __role.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}arcrole uses Python identifier arcrole
    __arcrole = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'arcrole'), 'arcrole', '__httpwww_opengis_netgml3_2_ResultType_httpwww_w3_org1999xlinkarcrole', _ImportedBinding_bindings_v1411_write__xlink.arcroleType)
    __arcrole._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 56, 1)
    __arcrole._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 115, 2)
    
    arcrole = property(__arcrole.value, __arcrole.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}title uses Python identifier title
    __title = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'title'), 'title', '__httpwww_opengis_netgml3_2_ResultType_httpwww_w3_org1999xlinktitle', _ImportedBinding_bindings_v1411_write__xlink.titleAttrType)
    __title._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 64, 1)
    __title._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 116, 2)
    
    title = property(__title.value, __title.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}show uses Python identifier show
    __show = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'show'), 'show', '__httpwww_opengis_netgml3_2_ResultType_httpwww_w3_org1999xlinkshow', _ImportedBinding_bindings_v1411_write__xlink.showType)
    __show._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 70, 1)
    __show._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 117, 2)
    
    show = property(__show.value, __show.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}actuate uses Python identifier actuate
    __actuate = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'actuate'), 'actuate', '__httpwww_opengis_netgml3_2_ResultType_httpwww_w3_org1999xlinkactuate', _ImportedBinding_bindings_v1411_write__xlink.actuateType)
    __actuate._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 82, 1)
    __actuate._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 118, 2)
    
    actuate = property(__actuate.value, __actuate.set, None, None)

    _HasWildcardElement = True
    _ElementMap.update({
        
    })
    _AttributeMap.update({
        __remoteSchema.name() : __remoteSchema,
        __nilReason.name() : __nilReason,
        __owns.name() : __owns,
        __type.name() : __type,
        __href.name() : __href,
        __role.name() : __role,
        __arcrole.name() : __arcrole,
        __title.name() : __title,
        __show.name() : __show,
        __actuate.name() : __actuate
    })
_module_typeBindings.ResultType = ResultType
_Namespace_gml.addCategoryObject('typeBinding', 'ResultType', ResultType)


# Complex type [anonymous] with content type ELEMENT_ONLY
class CTD_ANON_8 (pyxb.binding.basis.complexTypeDefinition):
    """The gml:domainOfValidity property implements an association role to an EX_Extent object as encoded in ISO/TS 19139, either referencing or containing the definition of that extent."""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = None
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/referenceSystems.xsd', 49, 2)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.isotc211.org/2005/gmd}EX_Extent uses Python identifier EX_Extent
    __EX_Extent = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'EX_Extent'), 'EX_Extent', '__httpwww_opengis_netgml3_2_CTD_ANON_8_httpwww_isotc211_org2005gmdEX_Extent', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/extent.xsd', 104, 1), )

    
    EX_Extent = property(__EX_Extent.value, __EX_Extent.set, None, None)

    
    # Attribute {http://www.opengis.net/gml/3.2}remoteSchema uses Python identifier remoteSchema
    __remoteSchema = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gml, 'remoteSchema'), 'remoteSchema', '__httpwww_opengis_netgml3_2_CTD_ANON_8_httpwww_opengis_netgml3_2remoteSchema', pyxb.binding.datatypes.anyURI)
    __remoteSchema._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 638, 1)
    __remoteSchema._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 52, 2)
    
    remoteSchema = property(__remoteSchema.value, __remoteSchema.set, None, '')

    
    # Attribute nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'nilReason'), 'nilReason', '__httpwww_opengis_netgml3_2_CTD_ANON_8_nilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 51, 2)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 51, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}type uses Python identifier type
    __type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'type'), 'type', '__httpwww_opengis_netgml3_2_CTD_ANON_8_httpwww_w3_org1999xlinktype', _ImportedBinding_bindings_v1411_write__xlink.typeType, fixed=True, unicode_default='simple')
    __type._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 29, 1)
    __type._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 112, 2)
    
    type = property(__type.value, __type.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}href uses Python identifier href
    __href = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'href'), 'href', '__httpwww_opengis_netgml3_2_CTD_ANON_8_httpwww_w3_org1999xlinkhref', _ImportedBinding_bindings_v1411_write__xlink.hrefType)
    __href._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 42, 1)
    __href._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 113, 2)
    
    href = property(__href.value, __href.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}role uses Python identifier role
    __role = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'role'), 'role', '__httpwww_opengis_netgml3_2_CTD_ANON_8_httpwww_w3_org1999xlinkrole', _ImportedBinding_bindings_v1411_write__xlink.roleType)
    __role._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 48, 1)
    __role._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 114, 2)
    
    role = property(__role.value, __role.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}arcrole uses Python identifier arcrole
    __arcrole = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'arcrole'), 'arcrole', '__httpwww_opengis_netgml3_2_CTD_ANON_8_httpwww_w3_org1999xlinkarcrole', _ImportedBinding_bindings_v1411_write__xlink.arcroleType)
    __arcrole._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 56, 1)
    __arcrole._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 115, 2)
    
    arcrole = property(__arcrole.value, __arcrole.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}title uses Python identifier title
    __title = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'title'), 'title', '__httpwww_opengis_netgml3_2_CTD_ANON_8_httpwww_w3_org1999xlinktitle', _ImportedBinding_bindings_v1411_write__xlink.titleAttrType)
    __title._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 64, 1)
    __title._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 116, 2)
    
    title = property(__title.value, __title.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}show uses Python identifier show
    __show = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'show'), 'show', '__httpwww_opengis_netgml3_2_CTD_ANON_8_httpwww_w3_org1999xlinkshow', _ImportedBinding_bindings_v1411_write__xlink.showType)
    __show._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 70, 1)
    __show._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 117, 2)
    
    show = property(__show.value, __show.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}actuate uses Python identifier actuate
    __actuate = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'actuate'), 'actuate', '__httpwww_opengis_netgml3_2_CTD_ANON_8_httpwww_w3_org1999xlinkactuate', _ImportedBinding_bindings_v1411_write__xlink.actuateType)
    __actuate._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 82, 1)
    __actuate._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 118, 2)
    
    actuate = property(__actuate.value, __actuate.set, None, None)

    _ElementMap.update({
        __EX_Extent.name() : __EX_Extent
    })
    _AttributeMap.update({
        __remoteSchema.name() : __remoteSchema,
        __nilReason.name() : __nilReason,
        __type.name() : __type,
        __href.name() : __href,
        __role.name() : __role,
        __arcrole.name() : __arcrole,
        __title.name() : __title,
        __show.name() : __show,
        __actuate.name() : __actuate
    })
_module_typeBindings.CTD_ANON_8 = CTD_ANON_8


# Complex type {http://www.opengis.net/gml/3.2}CRSPropertyType with content type ELEMENT_ONLY
class CRSPropertyType (pyxb.binding.basis.complexTypeDefinition):
    """gml:CRSPropertyType is a property type for association roles to a CRS abstract coordinate reference system, either referencing or containing the definition of that CRS."""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'CRSPropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/referenceSystems.xsd', 61, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.opengis.net/gml/3.2}AbstractCRS uses Python identifier AbstractCRS
    __AbstractCRS = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractCRS'), 'AbstractCRS', '__httpwww_opengis_netgml3_2_CRSPropertyType_httpwww_opengis_netgml3_2AbstractCRS', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/referenceSystems.xsd', 30, 1), )

    
    AbstractCRS = property(__AbstractCRS.value, __AbstractCRS.set, None, 'gml:AbstractCRS specifies a coordinate reference system which is usually single but may be compound. This abstract complex type shall not be used, extended, or restricted, in a GML Application Schema, to define a concrete subtype with a meaning equivalent to a concrete subtype specified in this document.')

    
    # Attribute {http://www.opengis.net/gml/3.2}remoteSchema uses Python identifier remoteSchema
    __remoteSchema = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gml, 'remoteSchema'), 'remoteSchema', '__httpwww_opengis_netgml3_2_CRSPropertyType_httpwww_opengis_netgml3_2remoteSchema', pyxb.binding.datatypes.anyURI)
    __remoteSchema._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 638, 1)
    __remoteSchema._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 52, 2)
    
    remoteSchema = property(__remoteSchema.value, __remoteSchema.set, None, '')

    
    # Attribute nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'nilReason'), 'nilReason', '__httpwww_opengis_netgml3_2_CRSPropertyType_nilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 51, 2)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 51, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}type uses Python identifier type
    __type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'type'), 'type', '__httpwww_opengis_netgml3_2_CRSPropertyType_httpwww_w3_org1999xlinktype', _ImportedBinding_bindings_v1411_write__xlink.typeType, fixed=True, unicode_default='simple')
    __type._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 29, 1)
    __type._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 112, 2)
    
    type = property(__type.value, __type.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}href uses Python identifier href
    __href = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'href'), 'href', '__httpwww_opengis_netgml3_2_CRSPropertyType_httpwww_w3_org1999xlinkhref', _ImportedBinding_bindings_v1411_write__xlink.hrefType)
    __href._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 42, 1)
    __href._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 113, 2)
    
    href = property(__href.value, __href.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}role uses Python identifier role
    __role = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'role'), 'role', '__httpwww_opengis_netgml3_2_CRSPropertyType_httpwww_w3_org1999xlinkrole', _ImportedBinding_bindings_v1411_write__xlink.roleType)
    __role._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 48, 1)
    __role._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 114, 2)
    
    role = property(__role.value, __role.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}arcrole uses Python identifier arcrole
    __arcrole = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'arcrole'), 'arcrole', '__httpwww_opengis_netgml3_2_CRSPropertyType_httpwww_w3_org1999xlinkarcrole', _ImportedBinding_bindings_v1411_write__xlink.arcroleType)
    __arcrole._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 56, 1)
    __arcrole._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 115, 2)
    
    arcrole = property(__arcrole.value, __arcrole.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}title uses Python identifier title
    __title = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'title'), 'title', '__httpwww_opengis_netgml3_2_CRSPropertyType_httpwww_w3_org1999xlinktitle', _ImportedBinding_bindings_v1411_write__xlink.titleAttrType)
    __title._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 64, 1)
    __title._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 116, 2)
    
    title = property(__title.value, __title.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}show uses Python identifier show
    __show = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'show'), 'show', '__httpwww_opengis_netgml3_2_CRSPropertyType_httpwww_w3_org1999xlinkshow', _ImportedBinding_bindings_v1411_write__xlink.showType)
    __show._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 70, 1)
    __show._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 117, 2)
    
    show = property(__show.value, __show.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}actuate uses Python identifier actuate
    __actuate = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'actuate'), 'actuate', '__httpwww_opengis_netgml3_2_CRSPropertyType_httpwww_w3_org1999xlinkactuate', _ImportedBinding_bindings_v1411_write__xlink.actuateType)
    __actuate._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 82, 1)
    __actuate._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 118, 2)
    
    actuate = property(__actuate.value, __actuate.set, None, None)

    _ElementMap.update({
        __AbstractCRS.name() : __AbstractCRS
    })
    _AttributeMap.update({
        __remoteSchema.name() : __remoteSchema,
        __nilReason.name() : __nilReason,
        __type.name() : __type,
        __href.name() : __href,
        __role.name() : __role,
        __arcrole.name() : __arcrole,
        __title.name() : __title,
        __show.name() : __show,
        __actuate.name() : __actuate
    })
_module_typeBindings.CRSPropertyType = CRSPropertyType
_Namespace_gml.addCategoryObject('typeBinding', 'CRSPropertyType', CRSPropertyType)


# Complex type {http://www.opengis.net/gml/3.2}AbstractTimePrimitiveType with content type ELEMENT_ONLY
class AbstractTimePrimitiveType (AbstractTimeObjectType):
    """Complex type {http://www.opengis.net/gml/3.2}AbstractTimePrimitiveType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = True
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractTimePrimitiveType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporal.xsd', 33, 1)
    _ElementMap = AbstractTimeObjectType._ElementMap.copy()
    _AttributeMap = AbstractTimeObjectType._AttributeMap.copy()
    # Base type is AbstractTimeObjectType
    
    # Element metaDataProperty ({http://www.opengis.net/gml/3.2}metaDataProperty) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element description ({http://www.opengis.net/gml/3.2}description) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element descriptionReference ({http://www.opengis.net/gml/3.2}descriptionReference) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element name ({http://www.opengis.net/gml/3.2}name) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element identifier ({http://www.opengis.net/gml/3.2}identifier) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element {http://www.opengis.net/gml/3.2}relatedTime uses Python identifier relatedTime
    __relatedTime = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'relatedTime'), 'relatedTime', '__httpwww_opengis_netgml3_2_AbstractTimePrimitiveType_httpwww_opengis_netgml3_2relatedTime', True, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporal.xsd', 37, 5), )

    
    relatedTime = property(__relatedTime.value, __relatedTime.set, None, None)

    
    # Attribute id inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    _ElementMap.update({
        __relatedTime.name() : __relatedTime
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.AbstractTimePrimitiveType = AbstractTimePrimitiveType
_Namespace_gml.addCategoryObject('typeBinding', 'AbstractTimePrimitiveType', AbstractTimePrimitiveType)


# Complex type {http://www.opengis.net/gml/3.2}TimePrimitivePropertyType with content type ELEMENT_ONLY
class TimePrimitivePropertyType (pyxb.binding.basis.complexTypeDefinition):
    """gml:TimePrimitivePropertyType provides a standard content model for associations between an arbitrary member of the substitution group whose head is gml:AbstractTimePrimitive and another object."""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'TimePrimitivePropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporal.xsd', 42, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.opengis.net/gml/3.2}AbstractTimePrimitive uses Python identifier AbstractTimePrimitive
    __AbstractTimePrimitive = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractTimePrimitive'), 'AbstractTimePrimitive', '__httpwww_opengis_netgml3_2_TimePrimitivePropertyType_httpwww_opengis_netgml3_2AbstractTimePrimitive', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporal.xsd', 28, 1), )

    
    AbstractTimePrimitive = property(__AbstractTimePrimitive.value, __AbstractTimePrimitive.set, None, 'gml:AbstractTimePrimitive acts as the head of a substitution group for geometric and topological temporal primitives.')

    
    # Attribute {http://www.opengis.net/gml/3.2}remoteSchema uses Python identifier remoteSchema
    __remoteSchema = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gml, 'remoteSchema'), 'remoteSchema', '__httpwww_opengis_netgml3_2_TimePrimitivePropertyType_httpwww_opengis_netgml3_2remoteSchema', pyxb.binding.datatypes.anyURI)
    __remoteSchema._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 638, 1)
    __remoteSchema._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 52, 2)
    
    remoteSchema = property(__remoteSchema.value, __remoteSchema.set, None, '')

    
    # Attribute nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'nilReason'), 'nilReason', '__httpwww_opengis_netgml3_2_TimePrimitivePropertyType_nilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 51, 2)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 51, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    
    # Attribute owns uses Python identifier owns
    __owns = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'owns'), 'owns', '__httpwww_opengis_netgml3_2_TimePrimitivePropertyType_owns', pyxb.binding.datatypes.boolean, unicode_default='false')
    __owns._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 79, 2)
    __owns._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 79, 2)
    
    owns = property(__owns.value, __owns.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}type uses Python identifier type
    __type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'type'), 'type', '__httpwww_opengis_netgml3_2_TimePrimitivePropertyType_httpwww_w3_org1999xlinktype', _ImportedBinding_bindings_v1411_write__xlink.typeType, fixed=True, unicode_default='simple')
    __type._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 29, 1)
    __type._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 112, 2)
    
    type = property(__type.value, __type.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}href uses Python identifier href
    __href = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'href'), 'href', '__httpwww_opengis_netgml3_2_TimePrimitivePropertyType_httpwww_w3_org1999xlinkhref', _ImportedBinding_bindings_v1411_write__xlink.hrefType)
    __href._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 42, 1)
    __href._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 113, 2)
    
    href = property(__href.value, __href.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}role uses Python identifier role
    __role = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'role'), 'role', '__httpwww_opengis_netgml3_2_TimePrimitivePropertyType_httpwww_w3_org1999xlinkrole', _ImportedBinding_bindings_v1411_write__xlink.roleType)
    __role._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 48, 1)
    __role._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 114, 2)
    
    role = property(__role.value, __role.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}arcrole uses Python identifier arcrole
    __arcrole = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'arcrole'), 'arcrole', '__httpwww_opengis_netgml3_2_TimePrimitivePropertyType_httpwww_w3_org1999xlinkarcrole', _ImportedBinding_bindings_v1411_write__xlink.arcroleType)
    __arcrole._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 56, 1)
    __arcrole._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 115, 2)
    
    arcrole = property(__arcrole.value, __arcrole.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}title uses Python identifier title
    __title = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'title'), 'title', '__httpwww_opengis_netgml3_2_TimePrimitivePropertyType_httpwww_w3_org1999xlinktitle', _ImportedBinding_bindings_v1411_write__xlink.titleAttrType)
    __title._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 64, 1)
    __title._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 116, 2)
    
    title = property(__title.value, __title.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}show uses Python identifier show
    __show = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'show'), 'show', '__httpwww_opengis_netgml3_2_TimePrimitivePropertyType_httpwww_w3_org1999xlinkshow', _ImportedBinding_bindings_v1411_write__xlink.showType)
    __show._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 70, 1)
    __show._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 117, 2)
    
    show = property(__show.value, __show.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}actuate uses Python identifier actuate
    __actuate = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'actuate'), 'actuate', '__httpwww_opengis_netgml3_2_TimePrimitivePropertyType_httpwww_w3_org1999xlinkactuate', _ImportedBinding_bindings_v1411_write__xlink.actuateType)
    __actuate._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 82, 1)
    __actuate._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 118, 2)
    
    actuate = property(__actuate.value, __actuate.set, None, None)

    _ElementMap.update({
        __AbstractTimePrimitive.name() : __AbstractTimePrimitive
    })
    _AttributeMap.update({
        __remoteSchema.name() : __remoteSchema,
        __nilReason.name() : __nilReason,
        __owns.name() : __owns,
        __type.name() : __type,
        __href.name() : __href,
        __role.name() : __role,
        __arcrole.name() : __arcrole,
        __title.name() : __title,
        __show.name() : __show,
        __actuate.name() : __actuate
    })
_module_typeBindings.TimePrimitivePropertyType = TimePrimitivePropertyType
_Namespace_gml.addCategoryObject('typeBinding', 'TimePrimitivePropertyType', TimePrimitivePropertyType)


# Complex type {http://www.opengis.net/gml/3.2}AbstractTimeComplexType with content type ELEMENT_ONLY
class AbstractTimeComplexType (AbstractTimeObjectType):
    """Complex type {http://www.opengis.net/gml/3.2}AbstractTimeComplexType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = True
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractTimeComplexType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporal.xsd', 90, 1)
    _ElementMap = AbstractTimeObjectType._ElementMap.copy()
    _AttributeMap = AbstractTimeObjectType._AttributeMap.copy()
    # Base type is AbstractTimeObjectType
    
    # Element metaDataProperty ({http://www.opengis.net/gml/3.2}metaDataProperty) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element description ({http://www.opengis.net/gml/3.2}description) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element descriptionReference ({http://www.opengis.net/gml/3.2}descriptionReference) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element name ({http://www.opengis.net/gml/3.2}name) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element identifier ({http://www.opengis.net/gml/3.2}identifier) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Attribute id inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    _ElementMap.update({
        
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.AbstractTimeComplexType = AbstractTimeComplexType
_Namespace_gml.addCategoryObject('typeBinding', 'AbstractTimeComplexType', AbstractTimeComplexType)


# Complex type {http://www.opengis.net/gml/3.2}TimeInstantPropertyType with content type ELEMENT_ONLY
class TimeInstantPropertyType (pyxb.binding.basis.complexTypeDefinition):
    """gml:TimeInstantPropertyType provides for associating a gml:TimeInstant with an object."""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'TimeInstantPropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporal.xsd', 123, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.opengis.net/gml/3.2}TimeInstant uses Python identifier TimeInstant
    __TimeInstant = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'TimeInstant'), 'TimeInstant', '__httpwww_opengis_netgml3_2_TimeInstantPropertyType_httpwww_opengis_netgml3_2TimeInstant', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporal.xsd', 109, 1), )

    
    TimeInstant = property(__TimeInstant.value, __TimeInstant.set, None, 'gml:TimeInstant acts as a zero-dimensional geometric primitive that represents an identifiable position in time.')

    
    # Attribute {http://www.opengis.net/gml/3.2}remoteSchema uses Python identifier remoteSchema
    __remoteSchema = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gml, 'remoteSchema'), 'remoteSchema', '__httpwww_opengis_netgml3_2_TimeInstantPropertyType_httpwww_opengis_netgml3_2remoteSchema', pyxb.binding.datatypes.anyURI)
    __remoteSchema._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 638, 1)
    __remoteSchema._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 52, 2)
    
    remoteSchema = property(__remoteSchema.value, __remoteSchema.set, None, '')

    
    # Attribute nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'nilReason'), 'nilReason', '__httpwww_opengis_netgml3_2_TimeInstantPropertyType_nilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 51, 2)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 51, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    
    # Attribute owns uses Python identifier owns
    __owns = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'owns'), 'owns', '__httpwww_opengis_netgml3_2_TimeInstantPropertyType_owns', pyxb.binding.datatypes.boolean, unicode_default='false')
    __owns._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 79, 2)
    __owns._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 79, 2)
    
    owns = property(__owns.value, __owns.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}type uses Python identifier type
    __type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'type'), 'type', '__httpwww_opengis_netgml3_2_TimeInstantPropertyType_httpwww_w3_org1999xlinktype', _ImportedBinding_bindings_v1411_write__xlink.typeType, fixed=True, unicode_default='simple')
    __type._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 29, 1)
    __type._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 112, 2)
    
    type = property(__type.value, __type.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}href uses Python identifier href
    __href = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'href'), 'href', '__httpwww_opengis_netgml3_2_TimeInstantPropertyType_httpwww_w3_org1999xlinkhref', _ImportedBinding_bindings_v1411_write__xlink.hrefType)
    __href._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 42, 1)
    __href._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 113, 2)
    
    href = property(__href.value, __href.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}role uses Python identifier role
    __role = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'role'), 'role', '__httpwww_opengis_netgml3_2_TimeInstantPropertyType_httpwww_w3_org1999xlinkrole', _ImportedBinding_bindings_v1411_write__xlink.roleType)
    __role._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 48, 1)
    __role._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 114, 2)
    
    role = property(__role.value, __role.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}arcrole uses Python identifier arcrole
    __arcrole = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'arcrole'), 'arcrole', '__httpwww_opengis_netgml3_2_TimeInstantPropertyType_httpwww_w3_org1999xlinkarcrole', _ImportedBinding_bindings_v1411_write__xlink.arcroleType)
    __arcrole._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 56, 1)
    __arcrole._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 115, 2)
    
    arcrole = property(__arcrole.value, __arcrole.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}title uses Python identifier title
    __title = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'title'), 'title', '__httpwww_opengis_netgml3_2_TimeInstantPropertyType_httpwww_w3_org1999xlinktitle', _ImportedBinding_bindings_v1411_write__xlink.titleAttrType)
    __title._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 64, 1)
    __title._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 116, 2)
    
    title = property(__title.value, __title.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}show uses Python identifier show
    __show = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'show'), 'show', '__httpwww_opengis_netgml3_2_TimeInstantPropertyType_httpwww_w3_org1999xlinkshow', _ImportedBinding_bindings_v1411_write__xlink.showType)
    __show._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 70, 1)
    __show._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 117, 2)
    
    show = property(__show.value, __show.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}actuate uses Python identifier actuate
    __actuate = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'actuate'), 'actuate', '__httpwww_opengis_netgml3_2_TimeInstantPropertyType_httpwww_w3_org1999xlinkactuate', _ImportedBinding_bindings_v1411_write__xlink.actuateType)
    __actuate._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 82, 1)
    __actuate._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 118, 2)
    
    actuate = property(__actuate.value, __actuate.set, None, None)

    _ElementMap.update({
        __TimeInstant.name() : __TimeInstant
    })
    _AttributeMap.update({
        __remoteSchema.name() : __remoteSchema,
        __nilReason.name() : __nilReason,
        __owns.name() : __owns,
        __type.name() : __type,
        __href.name() : __href,
        __role.name() : __role,
        __arcrole.name() : __arcrole,
        __title.name() : __title,
        __show.name() : __show,
        __actuate.name() : __actuate
    })
_module_typeBindings.TimeInstantPropertyType = TimeInstantPropertyType
_Namespace_gml.addCategoryObject('typeBinding', 'TimeInstantPropertyType', TimeInstantPropertyType)


# Complex type {http://www.opengis.net/gml/3.2}TimePeriodPropertyType with content type ELEMENT_ONLY
class TimePeriodPropertyType (pyxb.binding.basis.complexTypeDefinition):
    """gml:TimePeriodPropertyType provides for associating a gml:TimePeriod with an object."""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'TimePeriodPropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporal.xsd', 158, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.opengis.net/gml/3.2}TimePeriod uses Python identifier TimePeriod
    __TimePeriod = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'TimePeriod'), 'TimePeriod', '__httpwww_opengis_netgml3_2_TimePeriodPropertyType_httpwww_opengis_netgml3_2TimePeriod', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporal.xsd', 133, 1), )

    
    TimePeriod = property(__TimePeriod.value, __TimePeriod.set, None, 'gml:TimePeriod acts as a one-dimensional geometric primitive that represents an identifiable extent in time.\nThe location in of a gml:TimePeriod is described by the temporal positions of the instants at which it begins and ends. The length of the period is equal to the temporal distance between the two bounding temporal positions. \nBoth beginning and end may be described in terms of their direct position using gml:TimePositionType which is an XML Schema simple content type, or by reference to an indentifiable time instant using gml:TimeInstantPropertyType.\nAlternatively a limit of a gml:TimePeriod may use the conventional GML property model to make a reference to a time instant described elsewhere, or a limit may be indicated as a direct position.')

    
    # Attribute {http://www.opengis.net/gml/3.2}remoteSchema uses Python identifier remoteSchema
    __remoteSchema = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gml, 'remoteSchema'), 'remoteSchema', '__httpwww_opengis_netgml3_2_TimePeriodPropertyType_httpwww_opengis_netgml3_2remoteSchema', pyxb.binding.datatypes.anyURI)
    __remoteSchema._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 638, 1)
    __remoteSchema._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 52, 2)
    
    remoteSchema = property(__remoteSchema.value, __remoteSchema.set, None, '')

    
    # Attribute nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'nilReason'), 'nilReason', '__httpwww_opengis_netgml3_2_TimePeriodPropertyType_nilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 51, 2)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 51, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    
    # Attribute owns uses Python identifier owns
    __owns = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'owns'), 'owns', '__httpwww_opengis_netgml3_2_TimePeriodPropertyType_owns', pyxb.binding.datatypes.boolean, unicode_default='false')
    __owns._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 79, 2)
    __owns._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 79, 2)
    
    owns = property(__owns.value, __owns.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}type uses Python identifier type
    __type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'type'), 'type', '__httpwww_opengis_netgml3_2_TimePeriodPropertyType_httpwww_w3_org1999xlinktype', _ImportedBinding_bindings_v1411_write__xlink.typeType, fixed=True, unicode_default='simple')
    __type._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 29, 1)
    __type._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 112, 2)
    
    type = property(__type.value, __type.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}href uses Python identifier href
    __href = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'href'), 'href', '__httpwww_opengis_netgml3_2_TimePeriodPropertyType_httpwww_w3_org1999xlinkhref', _ImportedBinding_bindings_v1411_write__xlink.hrefType)
    __href._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 42, 1)
    __href._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 113, 2)
    
    href = property(__href.value, __href.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}role uses Python identifier role
    __role = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'role'), 'role', '__httpwww_opengis_netgml3_2_TimePeriodPropertyType_httpwww_w3_org1999xlinkrole', _ImportedBinding_bindings_v1411_write__xlink.roleType)
    __role._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 48, 1)
    __role._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 114, 2)
    
    role = property(__role.value, __role.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}arcrole uses Python identifier arcrole
    __arcrole = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'arcrole'), 'arcrole', '__httpwww_opengis_netgml3_2_TimePeriodPropertyType_httpwww_w3_org1999xlinkarcrole', _ImportedBinding_bindings_v1411_write__xlink.arcroleType)
    __arcrole._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 56, 1)
    __arcrole._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 115, 2)
    
    arcrole = property(__arcrole.value, __arcrole.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}title uses Python identifier title
    __title = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'title'), 'title', '__httpwww_opengis_netgml3_2_TimePeriodPropertyType_httpwww_w3_org1999xlinktitle', _ImportedBinding_bindings_v1411_write__xlink.titleAttrType)
    __title._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 64, 1)
    __title._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 116, 2)
    
    title = property(__title.value, __title.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}show uses Python identifier show
    __show = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'show'), 'show', '__httpwww_opengis_netgml3_2_TimePeriodPropertyType_httpwww_w3_org1999xlinkshow', _ImportedBinding_bindings_v1411_write__xlink.showType)
    __show._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 70, 1)
    __show._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 117, 2)
    
    show = property(__show.value, __show.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}actuate uses Python identifier actuate
    __actuate = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'actuate'), 'actuate', '__httpwww_opengis_netgml3_2_TimePeriodPropertyType_httpwww_w3_org1999xlinkactuate', _ImportedBinding_bindings_v1411_write__xlink.actuateType)
    __actuate._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 82, 1)
    __actuate._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 118, 2)
    
    actuate = property(__actuate.value, __actuate.set, None, None)

    _ElementMap.update({
        __TimePeriod.name() : __TimePeriod
    })
    _AttributeMap.update({
        __remoteSchema.name() : __remoteSchema,
        __nilReason.name() : __nilReason,
        __owns.name() : __owns,
        __type.name() : __type,
        __href.name() : __href,
        __role.name() : __role,
        __arcrole.name() : __arcrole,
        __title.name() : __title,
        __show.name() : __show,
        __actuate.name() : __actuate
    })
_module_typeBindings.TimePeriodPropertyType = TimePeriodPropertyType
_Namespace_gml.addCategoryObject('typeBinding', 'TimePeriodPropertyType', TimePeriodPropertyType)


# Complex type {http://www.opengis.net/gml/3.2}TimeIntervalLengthType with content type SIMPLE
class TimeIntervalLengthType (pyxb.binding.basis.complexTypeDefinition):
    """Complex type {http://www.opengis.net/gml/3.2}TimeIntervalLengthType with content type SIMPLE"""
    _TypeDefinition = pyxb.binding.datatypes.decimal
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_SIMPLE
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'TimeIntervalLengthType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporal.xsd', 241, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.decimal
    
    # Attribute unit uses Python identifier unit
    __unit = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'unit'), 'unit', '__httpwww_opengis_netgml3_2_TimeIntervalLengthType_unit', _module_typeBindings.TimeUnitType, required=True)
    __unit._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporal.xsd', 244, 4)
    __unit._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporal.xsd', 244, 4)
    
    unit = property(__unit.value, __unit.set, None, None)

    
    # Attribute radix uses Python identifier radix
    __radix = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'radix'), 'radix', '__httpwww_opengis_netgml3_2_TimeIntervalLengthType_radix', pyxb.binding.datatypes.positiveInteger)
    __radix._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporal.xsd', 245, 4)
    __radix._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporal.xsd', 245, 4)
    
    radix = property(__radix.value, __radix.set, None, None)

    
    # Attribute factor uses Python identifier factor
    __factor = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'factor'), 'factor', '__httpwww_opengis_netgml3_2_TimeIntervalLengthType_factor', pyxb.binding.datatypes.integer)
    __factor._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporal.xsd', 246, 4)
    __factor._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporal.xsd', 246, 4)
    
    factor = property(__factor.value, __factor.set, None, None)

    _ElementMap.update({
        
    })
    _AttributeMap.update({
        __unit.name() : __unit,
        __radix.name() : __radix,
        __factor.name() : __factor
    })
_module_typeBindings.TimeIntervalLengthType = TimeIntervalLengthType
_Namespace_gml.addCategoryObject('typeBinding', 'TimeIntervalLengthType', TimeIntervalLengthType)


# Complex type {http://www.opengis.net/gml/3.2}TimeCalendarPropertyType with content type ELEMENT_ONLY
class TimeCalendarPropertyType (pyxb.binding.basis.complexTypeDefinition):
    """gml:TimeCalendarPropertyType provides for associating a gml:TimeCalendar with an object."""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'TimeCalendarPropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporalReferenceSystems.xsd', 90, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.opengis.net/gml/3.2}TimeCalendar uses Python identifier TimeCalendar
    __TimeCalendar = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'TimeCalendar'), 'TimeCalendar', '__httpwww_opengis_netgml3_2_TimeCalendarPropertyType_httpwww_opengis_netgml3_2TimeCalendar', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporalReferenceSystems.xsd', 53, 1), )

    
    TimeCalendar = property(__TimeCalendar.value, __TimeCalendar.set, None, 'A calendar is a discrete temporal reference system that provides a basis for defining temporal position to a resolution of one day.\ngml:TimeCalendar adds one property to those inherited from gml:TimeReferenceSystem. A gml:referenceFrame provides a link to a gml:TimeCalendarEra that it uses. A  gml:TimeCalendar may reference more than one calendar era. \nThe referenceFrame element follows the standard GML property model, allowing the association to be instantiated either using an inline description using the gml:TimeCalendarEra element, or a link to a gml:TimeCalendarEra which is explicit elsewhere.')

    
    # Attribute {http://www.opengis.net/gml/3.2}remoteSchema uses Python identifier remoteSchema
    __remoteSchema = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gml, 'remoteSchema'), 'remoteSchema', '__httpwww_opengis_netgml3_2_TimeCalendarPropertyType_httpwww_opengis_netgml3_2remoteSchema', pyxb.binding.datatypes.anyURI)
    __remoteSchema._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 638, 1)
    __remoteSchema._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 52, 2)
    
    remoteSchema = property(__remoteSchema.value, __remoteSchema.set, None, '')

    
    # Attribute nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'nilReason'), 'nilReason', '__httpwww_opengis_netgml3_2_TimeCalendarPropertyType_nilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 51, 2)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 51, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    
    # Attribute owns uses Python identifier owns
    __owns = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'owns'), 'owns', '__httpwww_opengis_netgml3_2_TimeCalendarPropertyType_owns', pyxb.binding.datatypes.boolean, unicode_default='false')
    __owns._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 79, 2)
    __owns._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 79, 2)
    
    owns = property(__owns.value, __owns.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}type uses Python identifier type
    __type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'type'), 'type', '__httpwww_opengis_netgml3_2_TimeCalendarPropertyType_httpwww_w3_org1999xlinktype', _ImportedBinding_bindings_v1411_write__xlink.typeType, fixed=True, unicode_default='simple')
    __type._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 29, 1)
    __type._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 112, 2)
    
    type = property(__type.value, __type.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}href uses Python identifier href
    __href = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'href'), 'href', '__httpwww_opengis_netgml3_2_TimeCalendarPropertyType_httpwww_w3_org1999xlinkhref', _ImportedBinding_bindings_v1411_write__xlink.hrefType)
    __href._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 42, 1)
    __href._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 113, 2)
    
    href = property(__href.value, __href.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}role uses Python identifier role
    __role = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'role'), 'role', '__httpwww_opengis_netgml3_2_TimeCalendarPropertyType_httpwww_w3_org1999xlinkrole', _ImportedBinding_bindings_v1411_write__xlink.roleType)
    __role._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 48, 1)
    __role._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 114, 2)
    
    role = property(__role.value, __role.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}arcrole uses Python identifier arcrole
    __arcrole = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'arcrole'), 'arcrole', '__httpwww_opengis_netgml3_2_TimeCalendarPropertyType_httpwww_w3_org1999xlinkarcrole', _ImportedBinding_bindings_v1411_write__xlink.arcroleType)
    __arcrole._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 56, 1)
    __arcrole._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 115, 2)
    
    arcrole = property(__arcrole.value, __arcrole.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}title uses Python identifier title
    __title = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'title'), 'title', '__httpwww_opengis_netgml3_2_TimeCalendarPropertyType_httpwww_w3_org1999xlinktitle', _ImportedBinding_bindings_v1411_write__xlink.titleAttrType)
    __title._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 64, 1)
    __title._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 116, 2)
    
    title = property(__title.value, __title.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}show uses Python identifier show
    __show = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'show'), 'show', '__httpwww_opengis_netgml3_2_TimeCalendarPropertyType_httpwww_w3_org1999xlinkshow', _ImportedBinding_bindings_v1411_write__xlink.showType)
    __show._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 70, 1)
    __show._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 117, 2)
    
    show = property(__show.value, __show.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}actuate uses Python identifier actuate
    __actuate = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'actuate'), 'actuate', '__httpwww_opengis_netgml3_2_TimeCalendarPropertyType_httpwww_w3_org1999xlinkactuate', _ImportedBinding_bindings_v1411_write__xlink.actuateType)
    __actuate._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 82, 1)
    __actuate._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 118, 2)
    
    actuate = property(__actuate.value, __actuate.set, None, None)

    _ElementMap.update({
        __TimeCalendar.name() : __TimeCalendar
    })
    _AttributeMap.update({
        __remoteSchema.name() : __remoteSchema,
        __nilReason.name() : __nilReason,
        __owns.name() : __owns,
        __type.name() : __type,
        __href.name() : __href,
        __role.name() : __role,
        __arcrole.name() : __arcrole,
        __title.name() : __title,
        __show.name() : __show,
        __actuate.name() : __actuate
    })
_module_typeBindings.TimeCalendarPropertyType = TimeCalendarPropertyType
_Namespace_gml.addCategoryObject('typeBinding', 'TimeCalendarPropertyType', TimeCalendarPropertyType)


# Complex type {http://www.opengis.net/gml/3.2}TimeCalendarEraPropertyType with content type ELEMENT_ONLY
class TimeCalendarEraPropertyType (pyxb.binding.basis.complexTypeDefinition):
    """gml:TimeCalendarEraPropertyType provides for associating a gml:TimeCalendarEra with an object."""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'TimeCalendarEraPropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporalReferenceSystems.xsd', 100, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.opengis.net/gml/3.2}TimeCalendarEra uses Python identifier TimeCalendarEra
    __TimeCalendarEra = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'TimeCalendarEra'), 'TimeCalendarEra', '__httpwww_opengis_netgml3_2_TimeCalendarEraPropertyType_httpwww_opengis_netgml3_2TimeCalendarEra', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporalReferenceSystems.xsd', 69, 1), )

    
    TimeCalendarEra = property(__TimeCalendarEra.value, __TimeCalendarEra.set, None, 'gml:TimeCalendarEra inherits basic properties from gml:DefinitionType and has the following additional properties:\n-\tgml:referenceEvent is the name or description of a mythical or historic event which fixes the position of the base scale of the calendar era.  This is given as text or using a link to description held elsewhere.\n-\tgml:referenceDate specifies the date of the referenceEvent expressed as a date in the given calendar.  In most calendars, this date is the origin (i.e., the first day) of the scale, but this is not always true.\n-\tgml:julianReference specifies the Julian date that corresponds to the reference date.  The Julian day number is an integer value; the Julian date is a decimal value that allows greater resolution.  Transforming calendar dates to and from Julian dates provides a relatively simple basis for transforming dates from one calendar to another.\n-\tgml:epochOfUse is the period for which the calendar era was used as a basis for dating.')

    
    # Attribute {http://www.opengis.net/gml/3.2}remoteSchema uses Python identifier remoteSchema
    __remoteSchema = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gml, 'remoteSchema'), 'remoteSchema', '__httpwww_opengis_netgml3_2_TimeCalendarEraPropertyType_httpwww_opengis_netgml3_2remoteSchema', pyxb.binding.datatypes.anyURI)
    __remoteSchema._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 638, 1)
    __remoteSchema._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 52, 2)
    
    remoteSchema = property(__remoteSchema.value, __remoteSchema.set, None, '')

    
    # Attribute nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'nilReason'), 'nilReason', '__httpwww_opengis_netgml3_2_TimeCalendarEraPropertyType_nilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 51, 2)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 51, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    
    # Attribute owns uses Python identifier owns
    __owns = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'owns'), 'owns', '__httpwww_opengis_netgml3_2_TimeCalendarEraPropertyType_owns', pyxb.binding.datatypes.boolean, unicode_default='false')
    __owns._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 79, 2)
    __owns._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 79, 2)
    
    owns = property(__owns.value, __owns.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}type uses Python identifier type
    __type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'type'), 'type', '__httpwww_opengis_netgml3_2_TimeCalendarEraPropertyType_httpwww_w3_org1999xlinktype', _ImportedBinding_bindings_v1411_write__xlink.typeType, fixed=True, unicode_default='simple')
    __type._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 29, 1)
    __type._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 112, 2)
    
    type = property(__type.value, __type.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}href uses Python identifier href
    __href = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'href'), 'href', '__httpwww_opengis_netgml3_2_TimeCalendarEraPropertyType_httpwww_w3_org1999xlinkhref', _ImportedBinding_bindings_v1411_write__xlink.hrefType)
    __href._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 42, 1)
    __href._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 113, 2)
    
    href = property(__href.value, __href.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}role uses Python identifier role
    __role = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'role'), 'role', '__httpwww_opengis_netgml3_2_TimeCalendarEraPropertyType_httpwww_w3_org1999xlinkrole', _ImportedBinding_bindings_v1411_write__xlink.roleType)
    __role._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 48, 1)
    __role._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 114, 2)
    
    role = property(__role.value, __role.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}arcrole uses Python identifier arcrole
    __arcrole = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'arcrole'), 'arcrole', '__httpwww_opengis_netgml3_2_TimeCalendarEraPropertyType_httpwww_w3_org1999xlinkarcrole', _ImportedBinding_bindings_v1411_write__xlink.arcroleType)
    __arcrole._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 56, 1)
    __arcrole._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 115, 2)
    
    arcrole = property(__arcrole.value, __arcrole.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}title uses Python identifier title
    __title = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'title'), 'title', '__httpwww_opengis_netgml3_2_TimeCalendarEraPropertyType_httpwww_w3_org1999xlinktitle', _ImportedBinding_bindings_v1411_write__xlink.titleAttrType)
    __title._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 64, 1)
    __title._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 116, 2)
    
    title = property(__title.value, __title.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}show uses Python identifier show
    __show = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'show'), 'show', '__httpwww_opengis_netgml3_2_TimeCalendarEraPropertyType_httpwww_w3_org1999xlinkshow', _ImportedBinding_bindings_v1411_write__xlink.showType)
    __show._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 70, 1)
    __show._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 117, 2)
    
    show = property(__show.value, __show.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}actuate uses Python identifier actuate
    __actuate = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'actuate'), 'actuate', '__httpwww_opengis_netgml3_2_TimeCalendarEraPropertyType_httpwww_w3_org1999xlinkactuate', _ImportedBinding_bindings_v1411_write__xlink.actuateType)
    __actuate._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 82, 1)
    __actuate._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 118, 2)
    
    actuate = property(__actuate.value, __actuate.set, None, None)

    _ElementMap.update({
        __TimeCalendarEra.name() : __TimeCalendarEra
    })
    _AttributeMap.update({
        __remoteSchema.name() : __remoteSchema,
        __nilReason.name() : __nilReason,
        __owns.name() : __owns,
        __type.name() : __type,
        __href.name() : __href,
        __role.name() : __role,
        __arcrole.name() : __arcrole,
        __title.name() : __title,
        __show.name() : __show,
        __actuate.name() : __actuate
    })
_module_typeBindings.TimeCalendarEraPropertyType = TimeCalendarEraPropertyType
_Namespace_gml.addCategoryObject('typeBinding', 'TimeCalendarEraPropertyType', TimeCalendarEraPropertyType)


# Complex type {http://www.opengis.net/gml/3.2}TimeClockPropertyType with content type ELEMENT_ONLY
class TimeClockPropertyType (pyxb.binding.basis.complexTypeDefinition):
    """gml:TimeClockPropertyType provides for associating a gml:TimeClock with an object."""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'TimeClockPropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporalReferenceSystems.xsd', 132, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.opengis.net/gml/3.2}TimeClock uses Python identifier TimeClock
    __TimeClock = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'TimeClock'), 'TimeClock', '__httpwww_opengis_netgml3_2_TimeClockPropertyType_httpwww_opengis_netgml3_2TimeClock', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporalReferenceSystems.xsd', 110, 1), )

    
    TimeClock = property(__TimeClock.value, __TimeClock.set, None, 'A clock provides a basis for defining temporal position within a day. A clock shall be used with a calendar in order to provide a complete description of a temporal position within a specific day.\ngml:TimeClock adds the following properties to those inherited from gml:TimeReferenceSystemType:\n-\tgml:referenceEvent is the name or description of an event, such as solar noon or sunrise, which fixes the position of the base scale of the clock.\n-\tgml:referenceTime specifies the time of day associated with the reference event expressed as a time of day in the given clock. The reference time is usually the origin of the clock scale. \n-\tgml:utcReference specifies the 24 hour local or UTC time that corresponds to the reference time.\n-\tgml:dateBasis contains or references the calendars that use this clock.')

    
    # Attribute {http://www.opengis.net/gml/3.2}remoteSchema uses Python identifier remoteSchema
    __remoteSchema = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gml, 'remoteSchema'), 'remoteSchema', '__httpwww_opengis_netgml3_2_TimeClockPropertyType_httpwww_opengis_netgml3_2remoteSchema', pyxb.binding.datatypes.anyURI)
    __remoteSchema._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 638, 1)
    __remoteSchema._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 52, 2)
    
    remoteSchema = property(__remoteSchema.value, __remoteSchema.set, None, '')

    
    # Attribute nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'nilReason'), 'nilReason', '__httpwww_opengis_netgml3_2_TimeClockPropertyType_nilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 51, 2)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 51, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    
    # Attribute owns uses Python identifier owns
    __owns = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'owns'), 'owns', '__httpwww_opengis_netgml3_2_TimeClockPropertyType_owns', pyxb.binding.datatypes.boolean, unicode_default='false')
    __owns._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 79, 2)
    __owns._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 79, 2)
    
    owns = property(__owns.value, __owns.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}type uses Python identifier type
    __type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'type'), 'type', '__httpwww_opengis_netgml3_2_TimeClockPropertyType_httpwww_w3_org1999xlinktype', _ImportedBinding_bindings_v1411_write__xlink.typeType, fixed=True, unicode_default='simple')
    __type._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 29, 1)
    __type._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 112, 2)
    
    type = property(__type.value, __type.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}href uses Python identifier href
    __href = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'href'), 'href', '__httpwww_opengis_netgml3_2_TimeClockPropertyType_httpwww_w3_org1999xlinkhref', _ImportedBinding_bindings_v1411_write__xlink.hrefType)
    __href._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 42, 1)
    __href._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 113, 2)
    
    href = property(__href.value, __href.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}role uses Python identifier role
    __role = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'role'), 'role', '__httpwww_opengis_netgml3_2_TimeClockPropertyType_httpwww_w3_org1999xlinkrole', _ImportedBinding_bindings_v1411_write__xlink.roleType)
    __role._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 48, 1)
    __role._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 114, 2)
    
    role = property(__role.value, __role.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}arcrole uses Python identifier arcrole
    __arcrole = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'arcrole'), 'arcrole', '__httpwww_opengis_netgml3_2_TimeClockPropertyType_httpwww_w3_org1999xlinkarcrole', _ImportedBinding_bindings_v1411_write__xlink.arcroleType)
    __arcrole._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 56, 1)
    __arcrole._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 115, 2)
    
    arcrole = property(__arcrole.value, __arcrole.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}title uses Python identifier title
    __title = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'title'), 'title', '__httpwww_opengis_netgml3_2_TimeClockPropertyType_httpwww_w3_org1999xlinktitle', _ImportedBinding_bindings_v1411_write__xlink.titleAttrType)
    __title._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 64, 1)
    __title._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 116, 2)
    
    title = property(__title.value, __title.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}show uses Python identifier show
    __show = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'show'), 'show', '__httpwww_opengis_netgml3_2_TimeClockPropertyType_httpwww_w3_org1999xlinkshow', _ImportedBinding_bindings_v1411_write__xlink.showType)
    __show._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 70, 1)
    __show._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 117, 2)
    
    show = property(__show.value, __show.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}actuate uses Python identifier actuate
    __actuate = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'actuate'), 'actuate', '__httpwww_opengis_netgml3_2_TimeClockPropertyType_httpwww_w3_org1999xlinkactuate', _ImportedBinding_bindings_v1411_write__xlink.actuateType)
    __actuate._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 82, 1)
    __actuate._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 118, 2)
    
    actuate = property(__actuate.value, __actuate.set, None, None)

    _ElementMap.update({
        __TimeClock.name() : __TimeClock
    })
    _AttributeMap.update({
        __remoteSchema.name() : __remoteSchema,
        __nilReason.name() : __nilReason,
        __owns.name() : __owns,
        __type.name() : __type,
        __href.name() : __href,
        __role.name() : __role,
        __arcrole.name() : __arcrole,
        __title.name() : __title,
        __show.name() : __show,
        __actuate.name() : __actuate
    })
_module_typeBindings.TimeClockPropertyType = TimeClockPropertyType
_Namespace_gml.addCategoryObject('typeBinding', 'TimeClockPropertyType', TimeClockPropertyType)


# Complex type {http://www.opengis.net/gml/3.2}TimeOrdinalEraPropertyType with content type ELEMENT_ONLY
class TimeOrdinalEraPropertyType (pyxb.binding.basis.complexTypeDefinition):
    """gml:TimeOrdinalEraPropertyType provides for associating a gml:TimeOrdinalEra with an object."""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'TimeOrdinalEraPropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporalReferenceSystems.xsd', 179, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.opengis.net/gml/3.2}TimeOrdinalEra uses Python identifier TimeOrdinalEra
    __TimeOrdinalEra = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'TimeOrdinalEra'), 'TimeOrdinalEra', '__httpwww_opengis_netgml3_2_TimeOrdinalEraPropertyType_httpwww_opengis_netgml3_2TimeOrdinalEra', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporalReferenceSystems.xsd', 159, 1), )

    
    TimeOrdinalEra = property(__TimeOrdinalEra.value, __TimeOrdinalEra.set, None, 'Its content model follows the pattern of gml:TimeEdge, inheriting standard properties from gml:DefinitionType, and adding gml:start, gml:end and gml:extent properties, a set of gml:member properties which indicate ordered gml:TimeOrdinalEra elements, and a gml:group property which points to the parent era.\nThe recursive inclusion of gml:TimeOrdinalEra elements allow the construction of an arbitrary depth hierarchical ordinal reference schema, such that an ordinal era at a given level of the hierarchy includes a sequence of shorter, coterminous ordinal eras.')

    
    # Attribute {http://www.opengis.net/gml/3.2}remoteSchema uses Python identifier remoteSchema
    __remoteSchema = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gml, 'remoteSchema'), 'remoteSchema', '__httpwww_opengis_netgml3_2_TimeOrdinalEraPropertyType_httpwww_opengis_netgml3_2remoteSchema', pyxb.binding.datatypes.anyURI)
    __remoteSchema._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 638, 1)
    __remoteSchema._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 52, 2)
    
    remoteSchema = property(__remoteSchema.value, __remoteSchema.set, None, '')

    
    # Attribute nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'nilReason'), 'nilReason', '__httpwww_opengis_netgml3_2_TimeOrdinalEraPropertyType_nilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 51, 2)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 51, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    
    # Attribute owns uses Python identifier owns
    __owns = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'owns'), 'owns', '__httpwww_opengis_netgml3_2_TimeOrdinalEraPropertyType_owns', pyxb.binding.datatypes.boolean, unicode_default='false')
    __owns._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 79, 2)
    __owns._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 79, 2)
    
    owns = property(__owns.value, __owns.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}type uses Python identifier type
    __type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'type'), 'type', '__httpwww_opengis_netgml3_2_TimeOrdinalEraPropertyType_httpwww_w3_org1999xlinktype', _ImportedBinding_bindings_v1411_write__xlink.typeType, fixed=True, unicode_default='simple')
    __type._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 29, 1)
    __type._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 112, 2)
    
    type = property(__type.value, __type.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}href uses Python identifier href
    __href = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'href'), 'href', '__httpwww_opengis_netgml3_2_TimeOrdinalEraPropertyType_httpwww_w3_org1999xlinkhref', _ImportedBinding_bindings_v1411_write__xlink.hrefType)
    __href._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 42, 1)
    __href._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 113, 2)
    
    href = property(__href.value, __href.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}role uses Python identifier role
    __role = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'role'), 'role', '__httpwww_opengis_netgml3_2_TimeOrdinalEraPropertyType_httpwww_w3_org1999xlinkrole', _ImportedBinding_bindings_v1411_write__xlink.roleType)
    __role._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 48, 1)
    __role._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 114, 2)
    
    role = property(__role.value, __role.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}arcrole uses Python identifier arcrole
    __arcrole = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'arcrole'), 'arcrole', '__httpwww_opengis_netgml3_2_TimeOrdinalEraPropertyType_httpwww_w3_org1999xlinkarcrole', _ImportedBinding_bindings_v1411_write__xlink.arcroleType)
    __arcrole._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 56, 1)
    __arcrole._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 115, 2)
    
    arcrole = property(__arcrole.value, __arcrole.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}title uses Python identifier title
    __title = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'title'), 'title', '__httpwww_opengis_netgml3_2_TimeOrdinalEraPropertyType_httpwww_w3_org1999xlinktitle', _ImportedBinding_bindings_v1411_write__xlink.titleAttrType)
    __title._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 64, 1)
    __title._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 116, 2)
    
    title = property(__title.value, __title.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}show uses Python identifier show
    __show = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'show'), 'show', '__httpwww_opengis_netgml3_2_TimeOrdinalEraPropertyType_httpwww_w3_org1999xlinkshow', _ImportedBinding_bindings_v1411_write__xlink.showType)
    __show._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 70, 1)
    __show._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 117, 2)
    
    show = property(__show.value, __show.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}actuate uses Python identifier actuate
    __actuate = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'actuate'), 'actuate', '__httpwww_opengis_netgml3_2_TimeOrdinalEraPropertyType_httpwww_w3_org1999xlinkactuate', _ImportedBinding_bindings_v1411_write__xlink.actuateType)
    __actuate._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 82, 1)
    __actuate._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 118, 2)
    
    actuate = property(__actuate.value, __actuate.set, None, None)

    _ElementMap.update({
        __TimeOrdinalEra.name() : __TimeOrdinalEra
    })
    _AttributeMap.update({
        __remoteSchema.name() : __remoteSchema,
        __nilReason.name() : __nilReason,
        __owns.name() : __owns,
        __type.name() : __type,
        __href.name() : __href,
        __role.name() : __role,
        __arcrole.name() : __arcrole,
        __title.name() : __title,
        __show.name() : __show,
        __actuate.name() : __actuate
    })
_module_typeBindings.TimeOrdinalEraPropertyType = TimeOrdinalEraPropertyType
_Namespace_gml.addCategoryObject('typeBinding', 'TimeOrdinalEraPropertyType', TimeOrdinalEraPropertyType)


# Complex type {http://www.opengis.net/gml/3.2}TimeTopologyPrimitivePropertyType with content type ELEMENT_ONLY
class TimeTopologyPrimitivePropertyType (pyxb.binding.basis.complexTypeDefinition):
    """gml:TimeTopologyPrimitivePropertyType provides for associating a gml:AbstractTimeTopologyPrimitive with an object."""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'TimeTopologyPrimitivePropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporalTopology.xsd', 31, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.opengis.net/gml/3.2}AbstractTimeTopologyPrimitive uses Python identifier AbstractTimeTopologyPrimitive
    __AbstractTimeTopologyPrimitive = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractTimeTopologyPrimitive'), 'AbstractTimeTopologyPrimitive', '__httpwww_opengis_netgml3_2_TimeTopologyPrimitivePropertyType_httpwww_opengis_netgml3_2AbstractTimeTopologyPrimitive', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporalTopology.xsd', 15, 1), )

    
    AbstractTimeTopologyPrimitive = property(__AbstractTimeTopologyPrimitive.value, __AbstractTimeTopologyPrimitive.set, None, 'gml:TimeTopologyPrimitive acts as the head of a substitution group for topological temporal primitives.\nTemporal topology primitives shall imply the ordering information between features or feature properties. The temporal connection of features can be examined if they have temporal topology primitives as values of their properties. Usually, an instantaneous feature associates with a time node, and a static feature associates with a time edge.  A feature with both modes associates with the temporal topology primitive: a supertype of time nodes and time edges.\nA topological primitive is always connected to one or more other topological primitives, and is, therefore, always a member of a topological complex. In a GML instance, this will often be indicated by the primitives being described by elements that are descendents of an element describing a complex. However, in order to support the case where a temporal topological primitive is described in another context, the optional complex property is provided, which carries a reference to the parent temporal topological complex.')

    
    # Attribute {http://www.opengis.net/gml/3.2}remoteSchema uses Python identifier remoteSchema
    __remoteSchema = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gml, 'remoteSchema'), 'remoteSchema', '__httpwww_opengis_netgml3_2_TimeTopologyPrimitivePropertyType_httpwww_opengis_netgml3_2remoteSchema', pyxb.binding.datatypes.anyURI)
    __remoteSchema._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 638, 1)
    __remoteSchema._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 52, 2)
    
    remoteSchema = property(__remoteSchema.value, __remoteSchema.set, None, '')

    
    # Attribute nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'nilReason'), 'nilReason', '__httpwww_opengis_netgml3_2_TimeTopologyPrimitivePropertyType_nilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 51, 2)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 51, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    
    # Attribute owns uses Python identifier owns
    __owns = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'owns'), 'owns', '__httpwww_opengis_netgml3_2_TimeTopologyPrimitivePropertyType_owns', pyxb.binding.datatypes.boolean, unicode_default='false')
    __owns._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 79, 2)
    __owns._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 79, 2)
    
    owns = property(__owns.value, __owns.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}type uses Python identifier type
    __type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'type'), 'type', '__httpwww_opengis_netgml3_2_TimeTopologyPrimitivePropertyType_httpwww_w3_org1999xlinktype', _ImportedBinding_bindings_v1411_write__xlink.typeType, fixed=True, unicode_default='simple')
    __type._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 29, 1)
    __type._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 112, 2)
    
    type = property(__type.value, __type.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}href uses Python identifier href
    __href = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'href'), 'href', '__httpwww_opengis_netgml3_2_TimeTopologyPrimitivePropertyType_httpwww_w3_org1999xlinkhref', _ImportedBinding_bindings_v1411_write__xlink.hrefType)
    __href._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 42, 1)
    __href._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 113, 2)
    
    href = property(__href.value, __href.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}role uses Python identifier role
    __role = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'role'), 'role', '__httpwww_opengis_netgml3_2_TimeTopologyPrimitivePropertyType_httpwww_w3_org1999xlinkrole', _ImportedBinding_bindings_v1411_write__xlink.roleType)
    __role._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 48, 1)
    __role._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 114, 2)
    
    role = property(__role.value, __role.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}arcrole uses Python identifier arcrole
    __arcrole = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'arcrole'), 'arcrole', '__httpwww_opengis_netgml3_2_TimeTopologyPrimitivePropertyType_httpwww_w3_org1999xlinkarcrole', _ImportedBinding_bindings_v1411_write__xlink.arcroleType)
    __arcrole._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 56, 1)
    __arcrole._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 115, 2)
    
    arcrole = property(__arcrole.value, __arcrole.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}title uses Python identifier title
    __title = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'title'), 'title', '__httpwww_opengis_netgml3_2_TimeTopologyPrimitivePropertyType_httpwww_w3_org1999xlinktitle', _ImportedBinding_bindings_v1411_write__xlink.titleAttrType)
    __title._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 64, 1)
    __title._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 116, 2)
    
    title = property(__title.value, __title.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}show uses Python identifier show
    __show = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'show'), 'show', '__httpwww_opengis_netgml3_2_TimeTopologyPrimitivePropertyType_httpwww_w3_org1999xlinkshow', _ImportedBinding_bindings_v1411_write__xlink.showType)
    __show._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 70, 1)
    __show._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 117, 2)
    
    show = property(__show.value, __show.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}actuate uses Python identifier actuate
    __actuate = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'actuate'), 'actuate', '__httpwww_opengis_netgml3_2_TimeTopologyPrimitivePropertyType_httpwww_w3_org1999xlinkactuate', _ImportedBinding_bindings_v1411_write__xlink.actuateType)
    __actuate._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 82, 1)
    __actuate._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 118, 2)
    
    actuate = property(__actuate.value, __actuate.set, None, None)

    _ElementMap.update({
        __AbstractTimeTopologyPrimitive.name() : __AbstractTimeTopologyPrimitive
    })
    _AttributeMap.update({
        __remoteSchema.name() : __remoteSchema,
        __nilReason.name() : __nilReason,
        __owns.name() : __owns,
        __type.name() : __type,
        __href.name() : __href,
        __role.name() : __role,
        __arcrole.name() : __arcrole,
        __title.name() : __title,
        __show.name() : __show,
        __actuate.name() : __actuate
    })
_module_typeBindings.TimeTopologyPrimitivePropertyType = TimeTopologyPrimitivePropertyType
_Namespace_gml.addCategoryObject('typeBinding', 'TimeTopologyPrimitivePropertyType', TimeTopologyPrimitivePropertyType)


# Complex type {http://www.opengis.net/gml/3.2}TimeTopologyComplexPropertyType with content type ELEMENT_ONLY
class TimeTopologyComplexPropertyType (pyxb.binding.basis.complexTypeDefinition):
    """gml:TimeTopologyComplexPropertyType provides for associating a gml:TimeTopologyComplex with an object."""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'TimeTopologyComplexPropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporalTopology.xsd', 57, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.opengis.net/gml/3.2}TimeTopologyComplex uses Python identifier TimeTopologyComplex
    __TimeTopologyComplex = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'TimeTopologyComplex'), 'TimeTopologyComplex', '__httpwww_opengis_netgml3_2_TimeTopologyComplexPropertyType_httpwww_opengis_netgml3_2TimeTopologyComplex', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporalTopology.xsd', 41, 1), )

    
    TimeTopologyComplex = property(__TimeTopologyComplex.value, __TimeTopologyComplex.set, None, 'A temporal topology complex shall be the connected acyclic directed graph composed of temporal topological primitives, i.e. time nodes and time edges. Because a time edge may not exist without two time nodes on its boundaries, static features have time edges from a temporal topology complex as the values of their temporal properties, regardless of explicit declarations.\nA temporal topology complex expresses a linear or a non-linear graph. A temporal linear graph, composed of a sequence of time edges, provides a lineage described only by "substitution" of feature instances or feature element values. A time node as the start or the end of the graph connects with at least one time edge. A time node other than the start and the end shall connect to at least two time edges: one of starting from the node, and another ending at the node.\nA temporal topological complex is a set of connected temporal topological primitives. The member primtives are indicated, either by reference or by value, using the primitive property.')

    
    # Attribute {http://www.opengis.net/gml/3.2}remoteSchema uses Python identifier remoteSchema
    __remoteSchema = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gml, 'remoteSchema'), 'remoteSchema', '__httpwww_opengis_netgml3_2_TimeTopologyComplexPropertyType_httpwww_opengis_netgml3_2remoteSchema', pyxb.binding.datatypes.anyURI)
    __remoteSchema._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 638, 1)
    __remoteSchema._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 52, 2)
    
    remoteSchema = property(__remoteSchema.value, __remoteSchema.set, None, '')

    
    # Attribute nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'nilReason'), 'nilReason', '__httpwww_opengis_netgml3_2_TimeTopologyComplexPropertyType_nilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 51, 2)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 51, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    
    # Attribute owns uses Python identifier owns
    __owns = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'owns'), 'owns', '__httpwww_opengis_netgml3_2_TimeTopologyComplexPropertyType_owns', pyxb.binding.datatypes.boolean, unicode_default='false')
    __owns._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 79, 2)
    __owns._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 79, 2)
    
    owns = property(__owns.value, __owns.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}type uses Python identifier type
    __type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'type'), 'type', '__httpwww_opengis_netgml3_2_TimeTopologyComplexPropertyType_httpwww_w3_org1999xlinktype', _ImportedBinding_bindings_v1411_write__xlink.typeType, fixed=True, unicode_default='simple')
    __type._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 29, 1)
    __type._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 112, 2)
    
    type = property(__type.value, __type.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}href uses Python identifier href
    __href = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'href'), 'href', '__httpwww_opengis_netgml3_2_TimeTopologyComplexPropertyType_httpwww_w3_org1999xlinkhref', _ImportedBinding_bindings_v1411_write__xlink.hrefType)
    __href._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 42, 1)
    __href._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 113, 2)
    
    href = property(__href.value, __href.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}role uses Python identifier role
    __role = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'role'), 'role', '__httpwww_opengis_netgml3_2_TimeTopologyComplexPropertyType_httpwww_w3_org1999xlinkrole', _ImportedBinding_bindings_v1411_write__xlink.roleType)
    __role._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 48, 1)
    __role._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 114, 2)
    
    role = property(__role.value, __role.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}arcrole uses Python identifier arcrole
    __arcrole = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'arcrole'), 'arcrole', '__httpwww_opengis_netgml3_2_TimeTopologyComplexPropertyType_httpwww_w3_org1999xlinkarcrole', _ImportedBinding_bindings_v1411_write__xlink.arcroleType)
    __arcrole._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 56, 1)
    __arcrole._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 115, 2)
    
    arcrole = property(__arcrole.value, __arcrole.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}title uses Python identifier title
    __title = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'title'), 'title', '__httpwww_opengis_netgml3_2_TimeTopologyComplexPropertyType_httpwww_w3_org1999xlinktitle', _ImportedBinding_bindings_v1411_write__xlink.titleAttrType)
    __title._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 64, 1)
    __title._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 116, 2)
    
    title = property(__title.value, __title.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}show uses Python identifier show
    __show = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'show'), 'show', '__httpwww_opengis_netgml3_2_TimeTopologyComplexPropertyType_httpwww_w3_org1999xlinkshow', _ImportedBinding_bindings_v1411_write__xlink.showType)
    __show._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 70, 1)
    __show._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 117, 2)
    
    show = property(__show.value, __show.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}actuate uses Python identifier actuate
    __actuate = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'actuate'), 'actuate', '__httpwww_opengis_netgml3_2_TimeTopologyComplexPropertyType_httpwww_w3_org1999xlinkactuate', _ImportedBinding_bindings_v1411_write__xlink.actuateType)
    __actuate._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 82, 1)
    __actuate._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 118, 2)
    
    actuate = property(__actuate.value, __actuate.set, None, None)

    _ElementMap.update({
        __TimeTopologyComplex.name() : __TimeTopologyComplex
    })
    _AttributeMap.update({
        __remoteSchema.name() : __remoteSchema,
        __nilReason.name() : __nilReason,
        __owns.name() : __owns,
        __type.name() : __type,
        __href.name() : __href,
        __role.name() : __role,
        __arcrole.name() : __arcrole,
        __title.name() : __title,
        __show.name() : __show,
        __actuate.name() : __actuate
    })
_module_typeBindings.TimeTopologyComplexPropertyType = TimeTopologyComplexPropertyType
_Namespace_gml.addCategoryObject('typeBinding', 'TimeTopologyComplexPropertyType', TimeTopologyComplexPropertyType)


# Complex type {http://www.opengis.net/gml/3.2}TimeNodePropertyType with content type ELEMENT_ONLY
class TimeNodePropertyType (pyxb.binding.basis.complexTypeDefinition):
    """gml:TimeNodePropertyType provides for associating a gml:TimeNode with an object"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'TimeNodePropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporalTopology.xsd', 83, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.opengis.net/gml/3.2}TimeNode uses Python identifier TimeNode
    __TimeNode = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'TimeNode'), 'TimeNode', '__httpwww_opengis_netgml3_2_TimeNodePropertyType_httpwww_opengis_netgml3_2TimeNode', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporalTopology.xsd', 67, 1), )

    
    TimeNode = property(__TimeNode.value, __TimeNode.set, None, 'A time node is a zero-dimensional topological primitive that represents an identifiable node in time (it is equivalent to a point in space). A node may act as the termination or initiation of any number of time edges. A time node may be realised as a geometry, its position, whose value is a time instant.')

    
    # Attribute {http://www.opengis.net/gml/3.2}remoteSchema uses Python identifier remoteSchema
    __remoteSchema = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gml, 'remoteSchema'), 'remoteSchema', '__httpwww_opengis_netgml3_2_TimeNodePropertyType_httpwww_opengis_netgml3_2remoteSchema', pyxb.binding.datatypes.anyURI)
    __remoteSchema._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 638, 1)
    __remoteSchema._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 52, 2)
    
    remoteSchema = property(__remoteSchema.value, __remoteSchema.set, None, '')

    
    # Attribute nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'nilReason'), 'nilReason', '__httpwww_opengis_netgml3_2_TimeNodePropertyType_nilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 51, 2)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 51, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    
    # Attribute owns uses Python identifier owns
    __owns = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'owns'), 'owns', '__httpwww_opengis_netgml3_2_TimeNodePropertyType_owns', pyxb.binding.datatypes.boolean, unicode_default='false')
    __owns._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 79, 2)
    __owns._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 79, 2)
    
    owns = property(__owns.value, __owns.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}type uses Python identifier type
    __type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'type'), 'type', '__httpwww_opengis_netgml3_2_TimeNodePropertyType_httpwww_w3_org1999xlinktype', _ImportedBinding_bindings_v1411_write__xlink.typeType, fixed=True, unicode_default='simple')
    __type._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 29, 1)
    __type._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 112, 2)
    
    type = property(__type.value, __type.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}href uses Python identifier href
    __href = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'href'), 'href', '__httpwww_opengis_netgml3_2_TimeNodePropertyType_httpwww_w3_org1999xlinkhref', _ImportedBinding_bindings_v1411_write__xlink.hrefType)
    __href._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 42, 1)
    __href._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 113, 2)
    
    href = property(__href.value, __href.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}role uses Python identifier role
    __role = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'role'), 'role', '__httpwww_opengis_netgml3_2_TimeNodePropertyType_httpwww_w3_org1999xlinkrole', _ImportedBinding_bindings_v1411_write__xlink.roleType)
    __role._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 48, 1)
    __role._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 114, 2)
    
    role = property(__role.value, __role.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}arcrole uses Python identifier arcrole
    __arcrole = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'arcrole'), 'arcrole', '__httpwww_opengis_netgml3_2_TimeNodePropertyType_httpwww_w3_org1999xlinkarcrole', _ImportedBinding_bindings_v1411_write__xlink.arcroleType)
    __arcrole._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 56, 1)
    __arcrole._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 115, 2)
    
    arcrole = property(__arcrole.value, __arcrole.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}title uses Python identifier title
    __title = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'title'), 'title', '__httpwww_opengis_netgml3_2_TimeNodePropertyType_httpwww_w3_org1999xlinktitle', _ImportedBinding_bindings_v1411_write__xlink.titleAttrType)
    __title._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 64, 1)
    __title._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 116, 2)
    
    title = property(__title.value, __title.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}show uses Python identifier show
    __show = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'show'), 'show', '__httpwww_opengis_netgml3_2_TimeNodePropertyType_httpwww_w3_org1999xlinkshow', _ImportedBinding_bindings_v1411_write__xlink.showType)
    __show._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 70, 1)
    __show._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 117, 2)
    
    show = property(__show.value, __show.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}actuate uses Python identifier actuate
    __actuate = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'actuate'), 'actuate', '__httpwww_opengis_netgml3_2_TimeNodePropertyType_httpwww_w3_org1999xlinkactuate', _ImportedBinding_bindings_v1411_write__xlink.actuateType)
    __actuate._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 82, 1)
    __actuate._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 118, 2)
    
    actuate = property(__actuate.value, __actuate.set, None, None)

    _ElementMap.update({
        __TimeNode.name() : __TimeNode
    })
    _AttributeMap.update({
        __remoteSchema.name() : __remoteSchema,
        __nilReason.name() : __nilReason,
        __owns.name() : __owns,
        __type.name() : __type,
        __href.name() : __href,
        __role.name() : __role,
        __arcrole.name() : __arcrole,
        __title.name() : __title,
        __show.name() : __show,
        __actuate.name() : __actuate
    })
_module_typeBindings.TimeNodePropertyType = TimeNodePropertyType
_Namespace_gml.addCategoryObject('typeBinding', 'TimeNodePropertyType', TimeNodePropertyType)


# Complex type {http://www.opengis.net/gml/3.2}TimeEdgePropertyType with content type ELEMENT_ONLY
class TimeEdgePropertyType (pyxb.binding.basis.complexTypeDefinition):
    """gml:TimeEdgePropertyType provides for associating a gml:TimeEdge with an object."""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'TimeEdgePropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporalTopology.xsd', 109, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.opengis.net/gml/3.2}TimeEdge uses Python identifier TimeEdge
    __TimeEdge = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'TimeEdge'), 'TimeEdge', '__httpwww_opengis_netgml3_2_TimeEdgePropertyType_httpwww_opengis_netgml3_2TimeEdge', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporalTopology.xsd', 93, 1), )

    
    TimeEdge = property(__TimeEdge.value, __TimeEdge.set, None, 'A time edge is a one-dimensional topological primitive. It is an open interval that starts and ends at a node. The edge may be realised as a geometry whose value is a time period.')

    
    # Attribute {http://www.opengis.net/gml/3.2}remoteSchema uses Python identifier remoteSchema
    __remoteSchema = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gml, 'remoteSchema'), 'remoteSchema', '__httpwww_opengis_netgml3_2_TimeEdgePropertyType_httpwww_opengis_netgml3_2remoteSchema', pyxb.binding.datatypes.anyURI)
    __remoteSchema._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 638, 1)
    __remoteSchema._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 52, 2)
    
    remoteSchema = property(__remoteSchema.value, __remoteSchema.set, None, '')

    
    # Attribute nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'nilReason'), 'nilReason', '__httpwww_opengis_netgml3_2_TimeEdgePropertyType_nilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 51, 2)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 51, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    
    # Attribute owns uses Python identifier owns
    __owns = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'owns'), 'owns', '__httpwww_opengis_netgml3_2_TimeEdgePropertyType_owns', pyxb.binding.datatypes.boolean, unicode_default='false')
    __owns._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 79, 2)
    __owns._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 79, 2)
    
    owns = property(__owns.value, __owns.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}type uses Python identifier type
    __type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'type'), 'type', '__httpwww_opengis_netgml3_2_TimeEdgePropertyType_httpwww_w3_org1999xlinktype', _ImportedBinding_bindings_v1411_write__xlink.typeType, fixed=True, unicode_default='simple')
    __type._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 29, 1)
    __type._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 112, 2)
    
    type = property(__type.value, __type.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}href uses Python identifier href
    __href = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'href'), 'href', '__httpwww_opengis_netgml3_2_TimeEdgePropertyType_httpwww_w3_org1999xlinkhref', _ImportedBinding_bindings_v1411_write__xlink.hrefType)
    __href._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 42, 1)
    __href._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 113, 2)
    
    href = property(__href.value, __href.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}role uses Python identifier role
    __role = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'role'), 'role', '__httpwww_opengis_netgml3_2_TimeEdgePropertyType_httpwww_w3_org1999xlinkrole', _ImportedBinding_bindings_v1411_write__xlink.roleType)
    __role._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 48, 1)
    __role._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 114, 2)
    
    role = property(__role.value, __role.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}arcrole uses Python identifier arcrole
    __arcrole = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'arcrole'), 'arcrole', '__httpwww_opengis_netgml3_2_TimeEdgePropertyType_httpwww_w3_org1999xlinkarcrole', _ImportedBinding_bindings_v1411_write__xlink.arcroleType)
    __arcrole._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 56, 1)
    __arcrole._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 115, 2)
    
    arcrole = property(__arcrole.value, __arcrole.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}title uses Python identifier title
    __title = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'title'), 'title', '__httpwww_opengis_netgml3_2_TimeEdgePropertyType_httpwww_w3_org1999xlinktitle', _ImportedBinding_bindings_v1411_write__xlink.titleAttrType)
    __title._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 64, 1)
    __title._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 116, 2)
    
    title = property(__title.value, __title.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}show uses Python identifier show
    __show = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'show'), 'show', '__httpwww_opengis_netgml3_2_TimeEdgePropertyType_httpwww_w3_org1999xlinkshow', _ImportedBinding_bindings_v1411_write__xlink.showType)
    __show._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 70, 1)
    __show._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 117, 2)
    
    show = property(__show.value, __show.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}actuate uses Python identifier actuate
    __actuate = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'actuate'), 'actuate', '__httpwww_opengis_netgml3_2_TimeEdgePropertyType_httpwww_w3_org1999xlinkactuate', _ImportedBinding_bindings_v1411_write__xlink.actuateType)
    __actuate._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 82, 1)
    __actuate._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 118, 2)
    
    actuate = property(__actuate.value, __actuate.set, None, None)

    _ElementMap.update({
        __TimeEdge.name() : __TimeEdge
    })
    _AttributeMap.update({
        __remoteSchema.name() : __remoteSchema,
        __nilReason.name() : __nilReason,
        __owns.name() : __owns,
        __type.name() : __type,
        __href.name() : __href,
        __role.name() : __role,
        __arcrole.name() : __arcrole,
        __title.name() : __title,
        __show.name() : __show,
        __actuate.name() : __actuate
    })
_module_typeBindings.TimeEdgePropertyType = TimeEdgePropertyType
_Namespace_gml.addCategoryObject('typeBinding', 'TimeEdgePropertyType', TimeEdgePropertyType)


# Complex type {http://www.opengis.net/gml/3.2}AbstractTopoPrimitiveType with content type ELEMENT_ONLY
class AbstractTopoPrimitiveType (AbstractTopologyType):
    """Complex type {http://www.opengis.net/gml/3.2}AbstractTopoPrimitiveType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = True
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractTopoPrimitiveType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/topology.xsd', 26, 2)
    _ElementMap = AbstractTopologyType._ElementMap.copy()
    _AttributeMap = AbstractTopologyType._AttributeMap.copy()
    # Base type is AbstractTopologyType
    
    # Element metaDataProperty ({http://www.opengis.net/gml/3.2}metaDataProperty) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element description ({http://www.opengis.net/gml/3.2}description) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element descriptionReference ({http://www.opengis.net/gml/3.2}descriptionReference) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element name ({http://www.opengis.net/gml/3.2}name) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element identifier ({http://www.opengis.net/gml/3.2}identifier) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Attribute id inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    _ElementMap.update({
        
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.AbstractTopoPrimitiveType = AbstractTopoPrimitiveType
_Namespace_gml.addCategoryObject('typeBinding', 'AbstractTopoPrimitiveType', AbstractTopoPrimitiveType)


# Complex type {http://www.opengis.net/gml/3.2}NodeOrEdgePropertyType with content type ELEMENT_ONLY
class NodeOrEdgePropertyType (pyxb.binding.basis.complexTypeDefinition):
    """Complex type {http://www.opengis.net/gml/3.2}NodeOrEdgePropertyType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'NodeOrEdgePropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/topology.xsd', 37, 2)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.opengis.net/gml/3.2}Node uses Python identifier Node
    __Node = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'Node'), 'Node', '__httpwww_opengis_netgml3_2_NodeOrEdgePropertyType_httpwww_opengis_netgml3_2Node', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/topology.xsd', 83, 2), )

    
    Node = property(__Node.value, __Node.set, None, 'gml:Node represents the 0-dimensional primitive.\nThe optional coboundary of a node (gml:directedEdge) is a sequence of directed edges which are incident on this node. Edges emanating from this node appear in the node coboundary with a negative orientation. \nIf provided, the aggregationType attribute shall have the value "sequence".\nA node may optionally be realised by a 0-dimensional geometric primitive (gml:pointProperty).')

    
    # Element {http://www.opengis.net/gml/3.2}Edge uses Python identifier Edge
    __Edge = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'Edge'), 'Edge', '__httpwww_opengis_netgml3_2_NodeOrEdgePropertyType_httpwww_opengis_netgml3_2Edge', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/topology.xsd', 117, 2), )

    
    Edge = property(__Edge.value, __Edge.set, None, 'gml:Edge represents the 1-dimensional primitive.\nThe topological boundary of an Edge (gml:directedNode) consists of a negatively directed start Node and a positively directed end Node.   \nThe optional coboundary of an edge (gml:directedFace) is a circular sequence of directed faces which are incident on this edge in document order. In the 2D case, the orientation of the face on the left of the edge is "+"; the orientation of the face on the right on its right is "-". \nIf provided, the aggregationType attribute shall have the value "sequence".\nAn edge may optionally be realised by a 1-dimensional geometric primitive (gml:curveProperty).')

    
    # Attribute {http://www.opengis.net/gml/3.2}remoteSchema uses Python identifier remoteSchema
    __remoteSchema = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gml, 'remoteSchema'), 'remoteSchema', '__httpwww_opengis_netgml3_2_NodeOrEdgePropertyType_httpwww_opengis_netgml3_2remoteSchema', pyxb.binding.datatypes.anyURI)
    __remoteSchema._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 638, 1)
    __remoteSchema._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 52, 2)
    
    remoteSchema = property(__remoteSchema.value, __remoteSchema.set, None, '')

    
    # Attribute nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'nilReason'), 'nilReason', '__httpwww_opengis_netgml3_2_NodeOrEdgePropertyType_nilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 51, 2)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 51, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    
    # Attribute owns uses Python identifier owns
    __owns = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'owns'), 'owns', '__httpwww_opengis_netgml3_2_NodeOrEdgePropertyType_owns', pyxb.binding.datatypes.boolean, unicode_default='false')
    __owns._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 79, 2)
    __owns._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 79, 2)
    
    owns = property(__owns.value, __owns.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}type uses Python identifier type
    __type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'type'), 'type', '__httpwww_opengis_netgml3_2_NodeOrEdgePropertyType_httpwww_w3_org1999xlinktype', _ImportedBinding_bindings_v1411_write__xlink.typeType, fixed=True, unicode_default='simple')
    __type._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 29, 1)
    __type._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 112, 2)
    
    type = property(__type.value, __type.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}href uses Python identifier href
    __href = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'href'), 'href', '__httpwww_opengis_netgml3_2_NodeOrEdgePropertyType_httpwww_w3_org1999xlinkhref', _ImportedBinding_bindings_v1411_write__xlink.hrefType)
    __href._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 42, 1)
    __href._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 113, 2)
    
    href = property(__href.value, __href.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}role uses Python identifier role
    __role = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'role'), 'role', '__httpwww_opengis_netgml3_2_NodeOrEdgePropertyType_httpwww_w3_org1999xlinkrole', _ImportedBinding_bindings_v1411_write__xlink.roleType)
    __role._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 48, 1)
    __role._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 114, 2)
    
    role = property(__role.value, __role.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}arcrole uses Python identifier arcrole
    __arcrole = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'arcrole'), 'arcrole', '__httpwww_opengis_netgml3_2_NodeOrEdgePropertyType_httpwww_w3_org1999xlinkarcrole', _ImportedBinding_bindings_v1411_write__xlink.arcroleType)
    __arcrole._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 56, 1)
    __arcrole._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 115, 2)
    
    arcrole = property(__arcrole.value, __arcrole.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}title uses Python identifier title
    __title = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'title'), 'title', '__httpwww_opengis_netgml3_2_NodeOrEdgePropertyType_httpwww_w3_org1999xlinktitle', _ImportedBinding_bindings_v1411_write__xlink.titleAttrType)
    __title._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 64, 1)
    __title._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 116, 2)
    
    title = property(__title.value, __title.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}show uses Python identifier show
    __show = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'show'), 'show', '__httpwww_opengis_netgml3_2_NodeOrEdgePropertyType_httpwww_w3_org1999xlinkshow', _ImportedBinding_bindings_v1411_write__xlink.showType)
    __show._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 70, 1)
    __show._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 117, 2)
    
    show = property(__show.value, __show.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}actuate uses Python identifier actuate
    __actuate = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'actuate'), 'actuate', '__httpwww_opengis_netgml3_2_NodeOrEdgePropertyType_httpwww_w3_org1999xlinkactuate', _ImportedBinding_bindings_v1411_write__xlink.actuateType)
    __actuate._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 82, 1)
    __actuate._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 118, 2)
    
    actuate = property(__actuate.value, __actuate.set, None, None)

    _ElementMap.update({
        __Node.name() : __Node,
        __Edge.name() : __Edge
    })
    _AttributeMap.update({
        __remoteSchema.name() : __remoteSchema,
        __nilReason.name() : __nilReason,
        __owns.name() : __owns,
        __type.name() : __type,
        __href.name() : __href,
        __role.name() : __role,
        __arcrole.name() : __arcrole,
        __title.name() : __title,
        __show.name() : __show,
        __actuate.name() : __actuate
    })
_module_typeBindings.NodeOrEdgePropertyType = NodeOrEdgePropertyType
_Namespace_gml.addCategoryObject('typeBinding', 'NodeOrEdgePropertyType', NodeOrEdgePropertyType)


# Complex type {http://www.opengis.net/gml/3.2}NodePropertyType with content type ELEMENT_ONLY
class NodePropertyType (pyxb.binding.basis.complexTypeDefinition):
    """Complex type {http://www.opengis.net/gml/3.2}NodePropertyType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'NodePropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/topology.xsd', 45, 2)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.opengis.net/gml/3.2}Node uses Python identifier Node
    __Node = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'Node'), 'Node', '__httpwww_opengis_netgml3_2_NodePropertyType_httpwww_opengis_netgml3_2Node', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/topology.xsd', 83, 2), )

    
    Node = property(__Node.value, __Node.set, None, 'gml:Node represents the 0-dimensional primitive.\nThe optional coboundary of a node (gml:directedEdge) is a sequence of directed edges which are incident on this node. Edges emanating from this node appear in the node coboundary with a negative orientation. \nIf provided, the aggregationType attribute shall have the value "sequence".\nA node may optionally be realised by a 0-dimensional geometric primitive (gml:pointProperty).')

    
    # Attribute {http://www.opengis.net/gml/3.2}remoteSchema uses Python identifier remoteSchema
    __remoteSchema = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gml, 'remoteSchema'), 'remoteSchema', '__httpwww_opengis_netgml3_2_NodePropertyType_httpwww_opengis_netgml3_2remoteSchema', pyxb.binding.datatypes.anyURI)
    __remoteSchema._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 638, 1)
    __remoteSchema._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 52, 2)
    
    remoteSchema = property(__remoteSchema.value, __remoteSchema.set, None, '')

    
    # Attribute nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'nilReason'), 'nilReason', '__httpwww_opengis_netgml3_2_NodePropertyType_nilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 51, 2)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 51, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    
    # Attribute owns uses Python identifier owns
    __owns = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'owns'), 'owns', '__httpwww_opengis_netgml3_2_NodePropertyType_owns', pyxb.binding.datatypes.boolean, unicode_default='false')
    __owns._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 79, 2)
    __owns._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 79, 2)
    
    owns = property(__owns.value, __owns.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}type uses Python identifier type
    __type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'type'), 'type', '__httpwww_opengis_netgml3_2_NodePropertyType_httpwww_w3_org1999xlinktype', _ImportedBinding_bindings_v1411_write__xlink.typeType, fixed=True, unicode_default='simple')
    __type._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 29, 1)
    __type._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 112, 2)
    
    type = property(__type.value, __type.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}href uses Python identifier href
    __href = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'href'), 'href', '__httpwww_opengis_netgml3_2_NodePropertyType_httpwww_w3_org1999xlinkhref', _ImportedBinding_bindings_v1411_write__xlink.hrefType)
    __href._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 42, 1)
    __href._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 113, 2)
    
    href = property(__href.value, __href.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}role uses Python identifier role
    __role = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'role'), 'role', '__httpwww_opengis_netgml3_2_NodePropertyType_httpwww_w3_org1999xlinkrole', _ImportedBinding_bindings_v1411_write__xlink.roleType)
    __role._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 48, 1)
    __role._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 114, 2)
    
    role = property(__role.value, __role.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}arcrole uses Python identifier arcrole
    __arcrole = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'arcrole'), 'arcrole', '__httpwww_opengis_netgml3_2_NodePropertyType_httpwww_w3_org1999xlinkarcrole', _ImportedBinding_bindings_v1411_write__xlink.arcroleType)
    __arcrole._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 56, 1)
    __arcrole._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 115, 2)
    
    arcrole = property(__arcrole.value, __arcrole.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}title uses Python identifier title
    __title = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'title'), 'title', '__httpwww_opengis_netgml3_2_NodePropertyType_httpwww_w3_org1999xlinktitle', _ImportedBinding_bindings_v1411_write__xlink.titleAttrType)
    __title._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 64, 1)
    __title._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 116, 2)
    
    title = property(__title.value, __title.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}show uses Python identifier show
    __show = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'show'), 'show', '__httpwww_opengis_netgml3_2_NodePropertyType_httpwww_w3_org1999xlinkshow', _ImportedBinding_bindings_v1411_write__xlink.showType)
    __show._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 70, 1)
    __show._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 117, 2)
    
    show = property(__show.value, __show.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}actuate uses Python identifier actuate
    __actuate = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'actuate'), 'actuate', '__httpwww_opengis_netgml3_2_NodePropertyType_httpwww_w3_org1999xlinkactuate', _ImportedBinding_bindings_v1411_write__xlink.actuateType)
    __actuate._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 82, 1)
    __actuate._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 118, 2)
    
    actuate = property(__actuate.value, __actuate.set, None, None)

    _ElementMap.update({
        __Node.name() : __Node
    })
    _AttributeMap.update({
        __remoteSchema.name() : __remoteSchema,
        __nilReason.name() : __nilReason,
        __owns.name() : __owns,
        __type.name() : __type,
        __href.name() : __href,
        __role.name() : __role,
        __arcrole.name() : __arcrole,
        __title.name() : __title,
        __show.name() : __show,
        __actuate.name() : __actuate
    })
_module_typeBindings.NodePropertyType = NodePropertyType
_Namespace_gml.addCategoryObject('typeBinding', 'NodePropertyType', NodePropertyType)


# Complex type {http://www.opengis.net/gml/3.2}FaceOrTopoSolidPropertyType with content type ELEMENT_ONLY
class FaceOrTopoSolidPropertyType (pyxb.binding.basis.complexTypeDefinition):
    """Complex type {http://www.opengis.net/gml/3.2}FaceOrTopoSolidPropertyType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'FaceOrTopoSolidPropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/topology.xsd', 52, 2)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.opengis.net/gml/3.2}Face uses Python identifier Face
    __Face = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'Face'), 'Face', '__httpwww_opengis_netgml3_2_FaceOrTopoSolidPropertyType_httpwww_opengis_netgml3_2Face', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/topology.xsd', 157, 2), )

    
    Face = property(__Face.value, __Face.set, None, 'gml:Face represents the 2-dimensional topology primitive.\nThe topological boundary of a face (gml:directedEdge) consists of a sequence of directed edges. If provided, the aggregationType attribute shall have the value "sequence".\nThe optional coboundary of a face (gml:directedTopoSolid) is a pair of directed solids which are bounded by this face. A positively directed solid corresponds to a solid which lies in the direction of the negatively directed normal to the face in any geometric realisation. \nA face may optionally be realised by a 2-dimensional geometric primitive (gml:surfaceProperty).')

    
    # Element {http://www.opengis.net/gml/3.2}TopoSolid uses Python identifier TopoSolid
    __TopoSolid = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'TopoSolid'), 'TopoSolid', '__httpwww_opengis_netgml3_2_FaceOrTopoSolidPropertyType_httpwww_opengis_netgml3_2TopoSolid', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/topology.xsd', 195, 2), )

    
    TopoSolid = property(__TopoSolid.value, __TopoSolid.set, None, 'gml:TopoSolid represents the 3-dimensional topology primitive. \nThe topological boundary of a solid (gml:directedFace) consists of a set of directed faces.\nA solid may optionally be realised by a 3-dimensional geometric primitive (gml:solidProperty).')

    
    # Attribute {http://www.opengis.net/gml/3.2}remoteSchema uses Python identifier remoteSchema
    __remoteSchema = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gml, 'remoteSchema'), 'remoteSchema', '__httpwww_opengis_netgml3_2_FaceOrTopoSolidPropertyType_httpwww_opengis_netgml3_2remoteSchema', pyxb.binding.datatypes.anyURI)
    __remoteSchema._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 638, 1)
    __remoteSchema._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 52, 2)
    
    remoteSchema = property(__remoteSchema.value, __remoteSchema.set, None, '')

    
    # Attribute nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'nilReason'), 'nilReason', '__httpwww_opengis_netgml3_2_FaceOrTopoSolidPropertyType_nilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 51, 2)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 51, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    
    # Attribute owns uses Python identifier owns
    __owns = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'owns'), 'owns', '__httpwww_opengis_netgml3_2_FaceOrTopoSolidPropertyType_owns', pyxb.binding.datatypes.boolean, unicode_default='false')
    __owns._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 79, 2)
    __owns._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 79, 2)
    
    owns = property(__owns.value, __owns.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}type uses Python identifier type
    __type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'type'), 'type', '__httpwww_opengis_netgml3_2_FaceOrTopoSolidPropertyType_httpwww_w3_org1999xlinktype', _ImportedBinding_bindings_v1411_write__xlink.typeType, fixed=True, unicode_default='simple')
    __type._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 29, 1)
    __type._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 112, 2)
    
    type = property(__type.value, __type.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}href uses Python identifier href
    __href = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'href'), 'href', '__httpwww_opengis_netgml3_2_FaceOrTopoSolidPropertyType_httpwww_w3_org1999xlinkhref', _ImportedBinding_bindings_v1411_write__xlink.hrefType)
    __href._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 42, 1)
    __href._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 113, 2)
    
    href = property(__href.value, __href.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}role uses Python identifier role
    __role = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'role'), 'role', '__httpwww_opengis_netgml3_2_FaceOrTopoSolidPropertyType_httpwww_w3_org1999xlinkrole', _ImportedBinding_bindings_v1411_write__xlink.roleType)
    __role._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 48, 1)
    __role._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 114, 2)
    
    role = property(__role.value, __role.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}arcrole uses Python identifier arcrole
    __arcrole = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'arcrole'), 'arcrole', '__httpwww_opengis_netgml3_2_FaceOrTopoSolidPropertyType_httpwww_w3_org1999xlinkarcrole', _ImportedBinding_bindings_v1411_write__xlink.arcroleType)
    __arcrole._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 56, 1)
    __arcrole._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 115, 2)
    
    arcrole = property(__arcrole.value, __arcrole.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}title uses Python identifier title
    __title = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'title'), 'title', '__httpwww_opengis_netgml3_2_FaceOrTopoSolidPropertyType_httpwww_w3_org1999xlinktitle', _ImportedBinding_bindings_v1411_write__xlink.titleAttrType)
    __title._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 64, 1)
    __title._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 116, 2)
    
    title = property(__title.value, __title.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}show uses Python identifier show
    __show = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'show'), 'show', '__httpwww_opengis_netgml3_2_FaceOrTopoSolidPropertyType_httpwww_w3_org1999xlinkshow', _ImportedBinding_bindings_v1411_write__xlink.showType)
    __show._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 70, 1)
    __show._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 117, 2)
    
    show = property(__show.value, __show.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}actuate uses Python identifier actuate
    __actuate = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'actuate'), 'actuate', '__httpwww_opengis_netgml3_2_FaceOrTopoSolidPropertyType_httpwww_w3_org1999xlinkactuate', _ImportedBinding_bindings_v1411_write__xlink.actuateType)
    __actuate._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 82, 1)
    __actuate._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 118, 2)
    
    actuate = property(__actuate.value, __actuate.set, None, None)

    _ElementMap.update({
        __Face.name() : __Face,
        __TopoSolid.name() : __TopoSolid
    })
    _AttributeMap.update({
        __remoteSchema.name() : __remoteSchema,
        __nilReason.name() : __nilReason,
        __owns.name() : __owns,
        __type.name() : __type,
        __href.name() : __href,
        __role.name() : __role,
        __arcrole.name() : __arcrole,
        __title.name() : __title,
        __show.name() : __show,
        __actuate.name() : __actuate
    })
_module_typeBindings.FaceOrTopoSolidPropertyType = FaceOrTopoSolidPropertyType
_Namespace_gml.addCategoryObject('typeBinding', 'FaceOrTopoSolidPropertyType', FaceOrTopoSolidPropertyType)


# Complex type {http://www.opengis.net/gml/3.2}TopoSolidPropertyType with content type ELEMENT_ONLY
class TopoSolidPropertyType (pyxb.binding.basis.complexTypeDefinition):
    """Complex type {http://www.opengis.net/gml/3.2}TopoSolidPropertyType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'TopoSolidPropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/topology.xsd', 60, 2)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.opengis.net/gml/3.2}TopoSolid uses Python identifier TopoSolid
    __TopoSolid = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'TopoSolid'), 'TopoSolid', '__httpwww_opengis_netgml3_2_TopoSolidPropertyType_httpwww_opengis_netgml3_2TopoSolid', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/topology.xsd', 195, 2), )

    
    TopoSolid = property(__TopoSolid.value, __TopoSolid.set, None, 'gml:TopoSolid represents the 3-dimensional topology primitive. \nThe topological boundary of a solid (gml:directedFace) consists of a set of directed faces.\nA solid may optionally be realised by a 3-dimensional geometric primitive (gml:solidProperty).')

    
    # Attribute {http://www.opengis.net/gml/3.2}remoteSchema uses Python identifier remoteSchema
    __remoteSchema = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gml, 'remoteSchema'), 'remoteSchema', '__httpwww_opengis_netgml3_2_TopoSolidPropertyType_httpwww_opengis_netgml3_2remoteSchema', pyxb.binding.datatypes.anyURI)
    __remoteSchema._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 638, 1)
    __remoteSchema._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 52, 2)
    
    remoteSchema = property(__remoteSchema.value, __remoteSchema.set, None, '')

    
    # Attribute nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'nilReason'), 'nilReason', '__httpwww_opengis_netgml3_2_TopoSolidPropertyType_nilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 51, 2)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 51, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    
    # Attribute owns uses Python identifier owns
    __owns = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'owns'), 'owns', '__httpwww_opengis_netgml3_2_TopoSolidPropertyType_owns', pyxb.binding.datatypes.boolean, unicode_default='false')
    __owns._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 79, 2)
    __owns._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 79, 2)
    
    owns = property(__owns.value, __owns.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}type uses Python identifier type
    __type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'type'), 'type', '__httpwww_opengis_netgml3_2_TopoSolidPropertyType_httpwww_w3_org1999xlinktype', _ImportedBinding_bindings_v1411_write__xlink.typeType, fixed=True, unicode_default='simple')
    __type._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 29, 1)
    __type._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 112, 2)
    
    type = property(__type.value, __type.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}href uses Python identifier href
    __href = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'href'), 'href', '__httpwww_opengis_netgml3_2_TopoSolidPropertyType_httpwww_w3_org1999xlinkhref', _ImportedBinding_bindings_v1411_write__xlink.hrefType)
    __href._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 42, 1)
    __href._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 113, 2)
    
    href = property(__href.value, __href.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}role uses Python identifier role
    __role = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'role'), 'role', '__httpwww_opengis_netgml3_2_TopoSolidPropertyType_httpwww_w3_org1999xlinkrole', _ImportedBinding_bindings_v1411_write__xlink.roleType)
    __role._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 48, 1)
    __role._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 114, 2)
    
    role = property(__role.value, __role.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}arcrole uses Python identifier arcrole
    __arcrole = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'arcrole'), 'arcrole', '__httpwww_opengis_netgml3_2_TopoSolidPropertyType_httpwww_w3_org1999xlinkarcrole', _ImportedBinding_bindings_v1411_write__xlink.arcroleType)
    __arcrole._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 56, 1)
    __arcrole._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 115, 2)
    
    arcrole = property(__arcrole.value, __arcrole.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}title uses Python identifier title
    __title = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'title'), 'title', '__httpwww_opengis_netgml3_2_TopoSolidPropertyType_httpwww_w3_org1999xlinktitle', _ImportedBinding_bindings_v1411_write__xlink.titleAttrType)
    __title._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 64, 1)
    __title._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 116, 2)
    
    title = property(__title.value, __title.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}show uses Python identifier show
    __show = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'show'), 'show', '__httpwww_opengis_netgml3_2_TopoSolidPropertyType_httpwww_w3_org1999xlinkshow', _ImportedBinding_bindings_v1411_write__xlink.showType)
    __show._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 70, 1)
    __show._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 117, 2)
    
    show = property(__show.value, __show.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}actuate uses Python identifier actuate
    __actuate = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'actuate'), 'actuate', '__httpwww_opengis_netgml3_2_TopoSolidPropertyType_httpwww_w3_org1999xlinkactuate', _ImportedBinding_bindings_v1411_write__xlink.actuateType)
    __actuate._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 82, 1)
    __actuate._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 118, 2)
    
    actuate = property(__actuate.value, __actuate.set, None, None)

    _ElementMap.update({
        __TopoSolid.name() : __TopoSolid
    })
    _AttributeMap.update({
        __remoteSchema.name() : __remoteSchema,
        __nilReason.name() : __nilReason,
        __owns.name() : __owns,
        __type.name() : __type,
        __href.name() : __href,
        __role.name() : __role,
        __arcrole.name() : __arcrole,
        __title.name() : __title,
        __show.name() : __show,
        __actuate.name() : __actuate
    })
_module_typeBindings.TopoSolidPropertyType = TopoSolidPropertyType
_Namespace_gml.addCategoryObject('typeBinding', 'TopoSolidPropertyType', TopoSolidPropertyType)


# Complex type {http://www.opengis.net/gml/3.2}DirectedNodePropertyType with content type ELEMENT_ONLY
class DirectedNodePropertyType (pyxb.binding.basis.complexTypeDefinition):
    """Complex type {http://www.opengis.net/gml/3.2}DirectedNodePropertyType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'DirectedNodePropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/topology.xsd', 96, 2)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.opengis.net/gml/3.2}Node uses Python identifier Node
    __Node = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'Node'), 'Node', '__httpwww_opengis_netgml3_2_DirectedNodePropertyType_httpwww_opengis_netgml3_2Node', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/topology.xsd', 83, 2), )

    
    Node = property(__Node.value, __Node.set, None, 'gml:Node represents the 0-dimensional primitive.\nThe optional coboundary of a node (gml:directedEdge) is a sequence of directed edges which are incident on this node. Edges emanating from this node appear in the node coboundary with a negative orientation. \nIf provided, the aggregationType attribute shall have the value "sequence".\nA node may optionally be realised by a 0-dimensional geometric primitive (gml:pointProperty).')

    
    # Attribute {http://www.opengis.net/gml/3.2}remoteSchema uses Python identifier remoteSchema
    __remoteSchema = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gml, 'remoteSchema'), 'remoteSchema', '__httpwww_opengis_netgml3_2_DirectedNodePropertyType_httpwww_opengis_netgml3_2remoteSchema', pyxb.binding.datatypes.anyURI)
    __remoteSchema._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 638, 1)
    __remoteSchema._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 52, 2)
    
    remoteSchema = property(__remoteSchema.value, __remoteSchema.set, None, '')

    
    # Attribute nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'nilReason'), 'nilReason', '__httpwww_opengis_netgml3_2_DirectedNodePropertyType_nilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 51, 2)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 51, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    
    # Attribute owns uses Python identifier owns
    __owns = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'owns'), 'owns', '__httpwww_opengis_netgml3_2_DirectedNodePropertyType_owns', pyxb.binding.datatypes.boolean, unicode_default='false')
    __owns._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 79, 2)
    __owns._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 79, 2)
    
    owns = property(__owns.value, __owns.set, None, None)

    
    # Attribute orientation uses Python identifier orientation
    __orientation = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'orientation'), 'orientation', '__httpwww_opengis_netgml3_2_DirectedNodePropertyType_orientation', _module_typeBindings.SignType, unicode_default='+')
    __orientation._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/topology.xsd', 100, 4)
    __orientation._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/topology.xsd', 100, 4)
    
    orientation = property(__orientation.value, __orientation.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}type uses Python identifier type
    __type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'type'), 'type', '__httpwww_opengis_netgml3_2_DirectedNodePropertyType_httpwww_w3_org1999xlinktype', _ImportedBinding_bindings_v1411_write__xlink.typeType, fixed=True, unicode_default='simple')
    __type._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 29, 1)
    __type._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 112, 2)
    
    type = property(__type.value, __type.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}href uses Python identifier href
    __href = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'href'), 'href', '__httpwww_opengis_netgml3_2_DirectedNodePropertyType_httpwww_w3_org1999xlinkhref', _ImportedBinding_bindings_v1411_write__xlink.hrefType)
    __href._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 42, 1)
    __href._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 113, 2)
    
    href = property(__href.value, __href.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}role uses Python identifier role
    __role = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'role'), 'role', '__httpwww_opengis_netgml3_2_DirectedNodePropertyType_httpwww_w3_org1999xlinkrole', _ImportedBinding_bindings_v1411_write__xlink.roleType)
    __role._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 48, 1)
    __role._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 114, 2)
    
    role = property(__role.value, __role.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}arcrole uses Python identifier arcrole
    __arcrole = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'arcrole'), 'arcrole', '__httpwww_opengis_netgml3_2_DirectedNodePropertyType_httpwww_w3_org1999xlinkarcrole', _ImportedBinding_bindings_v1411_write__xlink.arcroleType)
    __arcrole._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 56, 1)
    __arcrole._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 115, 2)
    
    arcrole = property(__arcrole.value, __arcrole.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}title uses Python identifier title
    __title = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'title'), 'title', '__httpwww_opengis_netgml3_2_DirectedNodePropertyType_httpwww_w3_org1999xlinktitle', _ImportedBinding_bindings_v1411_write__xlink.titleAttrType)
    __title._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 64, 1)
    __title._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 116, 2)
    
    title = property(__title.value, __title.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}show uses Python identifier show
    __show = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'show'), 'show', '__httpwww_opengis_netgml3_2_DirectedNodePropertyType_httpwww_w3_org1999xlinkshow', _ImportedBinding_bindings_v1411_write__xlink.showType)
    __show._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 70, 1)
    __show._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 117, 2)
    
    show = property(__show.value, __show.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}actuate uses Python identifier actuate
    __actuate = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'actuate'), 'actuate', '__httpwww_opengis_netgml3_2_DirectedNodePropertyType_httpwww_w3_org1999xlinkactuate', _ImportedBinding_bindings_v1411_write__xlink.actuateType)
    __actuate._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 82, 1)
    __actuate._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 118, 2)
    
    actuate = property(__actuate.value, __actuate.set, None, None)

    _ElementMap.update({
        __Node.name() : __Node
    })
    _AttributeMap.update({
        __remoteSchema.name() : __remoteSchema,
        __nilReason.name() : __nilReason,
        __owns.name() : __owns,
        __orientation.name() : __orientation,
        __type.name() : __type,
        __href.name() : __href,
        __role.name() : __role,
        __arcrole.name() : __arcrole,
        __title.name() : __title,
        __show.name() : __show,
        __actuate.name() : __actuate
    })
_module_typeBindings.DirectedNodePropertyType = DirectedNodePropertyType
_Namespace_gml.addCategoryObject('typeBinding', 'DirectedNodePropertyType', DirectedNodePropertyType)


# Complex type {http://www.opengis.net/gml/3.2}DirectedEdgePropertyType with content type ELEMENT_ONLY
class DirectedEdgePropertyType (pyxb.binding.basis.complexTypeDefinition):
    """Complex type {http://www.opengis.net/gml/3.2}DirectedEdgePropertyType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'DirectedEdgePropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/topology.xsd', 131, 2)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.opengis.net/gml/3.2}Edge uses Python identifier Edge
    __Edge = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'Edge'), 'Edge', '__httpwww_opengis_netgml3_2_DirectedEdgePropertyType_httpwww_opengis_netgml3_2Edge', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/topology.xsd', 117, 2), )

    
    Edge = property(__Edge.value, __Edge.set, None, 'gml:Edge represents the 1-dimensional primitive.\nThe topological boundary of an Edge (gml:directedNode) consists of a negatively directed start Node and a positively directed end Node.   \nThe optional coboundary of an edge (gml:directedFace) is a circular sequence of directed faces which are incident on this edge in document order. In the 2D case, the orientation of the face on the left of the edge is "+"; the orientation of the face on the right on its right is "-". \nIf provided, the aggregationType attribute shall have the value "sequence".\nAn edge may optionally be realised by a 1-dimensional geometric primitive (gml:curveProperty).')

    
    # Attribute {http://www.opengis.net/gml/3.2}remoteSchema uses Python identifier remoteSchema
    __remoteSchema = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gml, 'remoteSchema'), 'remoteSchema', '__httpwww_opengis_netgml3_2_DirectedEdgePropertyType_httpwww_opengis_netgml3_2remoteSchema', pyxb.binding.datatypes.anyURI)
    __remoteSchema._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 638, 1)
    __remoteSchema._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 52, 2)
    
    remoteSchema = property(__remoteSchema.value, __remoteSchema.set, None, '')

    
    # Attribute nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'nilReason'), 'nilReason', '__httpwww_opengis_netgml3_2_DirectedEdgePropertyType_nilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 51, 2)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 51, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    
    # Attribute owns uses Python identifier owns
    __owns = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'owns'), 'owns', '__httpwww_opengis_netgml3_2_DirectedEdgePropertyType_owns', pyxb.binding.datatypes.boolean, unicode_default='false')
    __owns._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 79, 2)
    __owns._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 79, 2)
    
    owns = property(__owns.value, __owns.set, None, None)

    
    # Attribute orientation uses Python identifier orientation
    __orientation = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'orientation'), 'orientation', '__httpwww_opengis_netgml3_2_DirectedEdgePropertyType_orientation', _module_typeBindings.SignType, unicode_default='+')
    __orientation._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/topology.xsd', 135, 4)
    __orientation._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/topology.xsd', 135, 4)
    
    orientation = property(__orientation.value, __orientation.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}type uses Python identifier type
    __type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'type'), 'type', '__httpwww_opengis_netgml3_2_DirectedEdgePropertyType_httpwww_w3_org1999xlinktype', _ImportedBinding_bindings_v1411_write__xlink.typeType, fixed=True, unicode_default='simple')
    __type._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 29, 1)
    __type._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 112, 2)
    
    type = property(__type.value, __type.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}href uses Python identifier href
    __href = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'href'), 'href', '__httpwww_opengis_netgml3_2_DirectedEdgePropertyType_httpwww_w3_org1999xlinkhref', _ImportedBinding_bindings_v1411_write__xlink.hrefType)
    __href._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 42, 1)
    __href._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 113, 2)
    
    href = property(__href.value, __href.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}role uses Python identifier role
    __role = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'role'), 'role', '__httpwww_opengis_netgml3_2_DirectedEdgePropertyType_httpwww_w3_org1999xlinkrole', _ImportedBinding_bindings_v1411_write__xlink.roleType)
    __role._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 48, 1)
    __role._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 114, 2)
    
    role = property(__role.value, __role.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}arcrole uses Python identifier arcrole
    __arcrole = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'arcrole'), 'arcrole', '__httpwww_opengis_netgml3_2_DirectedEdgePropertyType_httpwww_w3_org1999xlinkarcrole', _ImportedBinding_bindings_v1411_write__xlink.arcroleType)
    __arcrole._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 56, 1)
    __arcrole._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 115, 2)
    
    arcrole = property(__arcrole.value, __arcrole.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}title uses Python identifier title
    __title = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'title'), 'title', '__httpwww_opengis_netgml3_2_DirectedEdgePropertyType_httpwww_w3_org1999xlinktitle', _ImportedBinding_bindings_v1411_write__xlink.titleAttrType)
    __title._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 64, 1)
    __title._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 116, 2)
    
    title = property(__title.value, __title.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}show uses Python identifier show
    __show = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'show'), 'show', '__httpwww_opengis_netgml3_2_DirectedEdgePropertyType_httpwww_w3_org1999xlinkshow', _ImportedBinding_bindings_v1411_write__xlink.showType)
    __show._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 70, 1)
    __show._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 117, 2)
    
    show = property(__show.value, __show.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}actuate uses Python identifier actuate
    __actuate = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'actuate'), 'actuate', '__httpwww_opengis_netgml3_2_DirectedEdgePropertyType_httpwww_w3_org1999xlinkactuate', _ImportedBinding_bindings_v1411_write__xlink.actuateType)
    __actuate._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 82, 1)
    __actuate._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 118, 2)
    
    actuate = property(__actuate.value, __actuate.set, None, None)

    _ElementMap.update({
        __Edge.name() : __Edge
    })
    _AttributeMap.update({
        __remoteSchema.name() : __remoteSchema,
        __nilReason.name() : __nilReason,
        __owns.name() : __owns,
        __orientation.name() : __orientation,
        __type.name() : __type,
        __href.name() : __href,
        __role.name() : __role,
        __arcrole.name() : __arcrole,
        __title.name() : __title,
        __show.name() : __show,
        __actuate.name() : __actuate
    })
_module_typeBindings.DirectedEdgePropertyType = DirectedEdgePropertyType
_Namespace_gml.addCategoryObject('typeBinding', 'DirectedEdgePropertyType', DirectedEdgePropertyType)


# Complex type {http://www.opengis.net/gml/3.2}DirectedFacePropertyType with content type ELEMENT_ONLY
class DirectedFacePropertyType (pyxb.binding.basis.complexTypeDefinition):
    """Complex type {http://www.opengis.net/gml/3.2}DirectedFacePropertyType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'DirectedFacePropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/topology.xsd', 170, 2)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.opengis.net/gml/3.2}Face uses Python identifier Face
    __Face = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'Face'), 'Face', '__httpwww_opengis_netgml3_2_DirectedFacePropertyType_httpwww_opengis_netgml3_2Face', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/topology.xsd', 157, 2), )

    
    Face = property(__Face.value, __Face.set, None, 'gml:Face represents the 2-dimensional topology primitive.\nThe topological boundary of a face (gml:directedEdge) consists of a sequence of directed edges. If provided, the aggregationType attribute shall have the value "sequence".\nThe optional coboundary of a face (gml:directedTopoSolid) is a pair of directed solids which are bounded by this face. A positively directed solid corresponds to a solid which lies in the direction of the negatively directed normal to the face in any geometric realisation. \nA face may optionally be realised by a 2-dimensional geometric primitive (gml:surfaceProperty).')

    
    # Attribute {http://www.opengis.net/gml/3.2}remoteSchema uses Python identifier remoteSchema
    __remoteSchema = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gml, 'remoteSchema'), 'remoteSchema', '__httpwww_opengis_netgml3_2_DirectedFacePropertyType_httpwww_opengis_netgml3_2remoteSchema', pyxb.binding.datatypes.anyURI)
    __remoteSchema._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 638, 1)
    __remoteSchema._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 52, 2)
    
    remoteSchema = property(__remoteSchema.value, __remoteSchema.set, None, '')

    
    # Attribute nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'nilReason'), 'nilReason', '__httpwww_opengis_netgml3_2_DirectedFacePropertyType_nilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 51, 2)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 51, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    
    # Attribute owns uses Python identifier owns
    __owns = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'owns'), 'owns', '__httpwww_opengis_netgml3_2_DirectedFacePropertyType_owns', pyxb.binding.datatypes.boolean, unicode_default='false')
    __owns._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 79, 2)
    __owns._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 79, 2)
    
    owns = property(__owns.value, __owns.set, None, None)

    
    # Attribute orientation uses Python identifier orientation
    __orientation = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'orientation'), 'orientation', '__httpwww_opengis_netgml3_2_DirectedFacePropertyType_orientation', _module_typeBindings.SignType, unicode_default='+')
    __orientation._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/topology.xsd', 174, 4)
    __orientation._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/topology.xsd', 174, 4)
    
    orientation = property(__orientation.value, __orientation.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}type uses Python identifier type
    __type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'type'), 'type', '__httpwww_opengis_netgml3_2_DirectedFacePropertyType_httpwww_w3_org1999xlinktype', _ImportedBinding_bindings_v1411_write__xlink.typeType, fixed=True, unicode_default='simple')
    __type._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 29, 1)
    __type._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 112, 2)
    
    type = property(__type.value, __type.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}href uses Python identifier href
    __href = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'href'), 'href', '__httpwww_opengis_netgml3_2_DirectedFacePropertyType_httpwww_w3_org1999xlinkhref', _ImportedBinding_bindings_v1411_write__xlink.hrefType)
    __href._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 42, 1)
    __href._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 113, 2)
    
    href = property(__href.value, __href.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}role uses Python identifier role
    __role = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'role'), 'role', '__httpwww_opengis_netgml3_2_DirectedFacePropertyType_httpwww_w3_org1999xlinkrole', _ImportedBinding_bindings_v1411_write__xlink.roleType)
    __role._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 48, 1)
    __role._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 114, 2)
    
    role = property(__role.value, __role.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}arcrole uses Python identifier arcrole
    __arcrole = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'arcrole'), 'arcrole', '__httpwww_opengis_netgml3_2_DirectedFacePropertyType_httpwww_w3_org1999xlinkarcrole', _ImportedBinding_bindings_v1411_write__xlink.arcroleType)
    __arcrole._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 56, 1)
    __arcrole._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 115, 2)
    
    arcrole = property(__arcrole.value, __arcrole.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}title uses Python identifier title
    __title = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'title'), 'title', '__httpwww_opengis_netgml3_2_DirectedFacePropertyType_httpwww_w3_org1999xlinktitle', _ImportedBinding_bindings_v1411_write__xlink.titleAttrType)
    __title._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 64, 1)
    __title._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 116, 2)
    
    title = property(__title.value, __title.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}show uses Python identifier show
    __show = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'show'), 'show', '__httpwww_opengis_netgml3_2_DirectedFacePropertyType_httpwww_w3_org1999xlinkshow', _ImportedBinding_bindings_v1411_write__xlink.showType)
    __show._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 70, 1)
    __show._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 117, 2)
    
    show = property(__show.value, __show.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}actuate uses Python identifier actuate
    __actuate = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'actuate'), 'actuate', '__httpwww_opengis_netgml3_2_DirectedFacePropertyType_httpwww_w3_org1999xlinkactuate', _ImportedBinding_bindings_v1411_write__xlink.actuateType)
    __actuate._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 82, 1)
    __actuate._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 118, 2)
    
    actuate = property(__actuate.value, __actuate.set, None, None)

    _ElementMap.update({
        __Face.name() : __Face
    })
    _AttributeMap.update({
        __remoteSchema.name() : __remoteSchema,
        __nilReason.name() : __nilReason,
        __owns.name() : __owns,
        __orientation.name() : __orientation,
        __type.name() : __type,
        __href.name() : __href,
        __role.name() : __role,
        __arcrole.name() : __arcrole,
        __title.name() : __title,
        __show.name() : __show,
        __actuate.name() : __actuate
    })
_module_typeBindings.DirectedFacePropertyType = DirectedFacePropertyType
_Namespace_gml.addCategoryObject('typeBinding', 'DirectedFacePropertyType', DirectedFacePropertyType)


# Complex type {http://www.opengis.net/gml/3.2}DirectedTopoSolidPropertyType with content type ELEMENT_ONLY
class DirectedTopoSolidPropertyType (pyxb.binding.basis.complexTypeDefinition):
    """Complex type {http://www.opengis.net/gml/3.2}DirectedTopoSolidPropertyType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'DirectedTopoSolidPropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/topology.xsd', 207, 2)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.opengis.net/gml/3.2}TopoSolid uses Python identifier TopoSolid
    __TopoSolid = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'TopoSolid'), 'TopoSolid', '__httpwww_opengis_netgml3_2_DirectedTopoSolidPropertyType_httpwww_opengis_netgml3_2TopoSolid', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/topology.xsd', 195, 2), )

    
    TopoSolid = property(__TopoSolid.value, __TopoSolid.set, None, 'gml:TopoSolid represents the 3-dimensional topology primitive. \nThe topological boundary of a solid (gml:directedFace) consists of a set of directed faces.\nA solid may optionally be realised by a 3-dimensional geometric primitive (gml:solidProperty).')

    
    # Attribute {http://www.opengis.net/gml/3.2}remoteSchema uses Python identifier remoteSchema
    __remoteSchema = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gml, 'remoteSchema'), 'remoteSchema', '__httpwww_opengis_netgml3_2_DirectedTopoSolidPropertyType_httpwww_opengis_netgml3_2remoteSchema', pyxb.binding.datatypes.anyURI)
    __remoteSchema._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 638, 1)
    __remoteSchema._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 52, 2)
    
    remoteSchema = property(__remoteSchema.value, __remoteSchema.set, None, '')

    
    # Attribute nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'nilReason'), 'nilReason', '__httpwww_opengis_netgml3_2_DirectedTopoSolidPropertyType_nilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 51, 2)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 51, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    
    # Attribute owns uses Python identifier owns
    __owns = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'owns'), 'owns', '__httpwww_opengis_netgml3_2_DirectedTopoSolidPropertyType_owns', pyxb.binding.datatypes.boolean, unicode_default='false')
    __owns._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 79, 2)
    __owns._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 79, 2)
    
    owns = property(__owns.value, __owns.set, None, None)

    
    # Attribute orientation uses Python identifier orientation
    __orientation = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'orientation'), 'orientation', '__httpwww_opengis_netgml3_2_DirectedTopoSolidPropertyType_orientation', _module_typeBindings.SignType, unicode_default='+')
    __orientation._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/topology.xsd', 211, 4)
    __orientation._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/topology.xsd', 211, 4)
    
    orientation = property(__orientation.value, __orientation.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}type uses Python identifier type
    __type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'type'), 'type', '__httpwww_opengis_netgml3_2_DirectedTopoSolidPropertyType_httpwww_w3_org1999xlinktype', _ImportedBinding_bindings_v1411_write__xlink.typeType, fixed=True, unicode_default='simple')
    __type._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 29, 1)
    __type._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 112, 2)
    
    type = property(__type.value, __type.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}href uses Python identifier href
    __href = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'href'), 'href', '__httpwww_opengis_netgml3_2_DirectedTopoSolidPropertyType_httpwww_w3_org1999xlinkhref', _ImportedBinding_bindings_v1411_write__xlink.hrefType)
    __href._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 42, 1)
    __href._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 113, 2)
    
    href = property(__href.value, __href.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}role uses Python identifier role
    __role = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'role'), 'role', '__httpwww_opengis_netgml3_2_DirectedTopoSolidPropertyType_httpwww_w3_org1999xlinkrole', _ImportedBinding_bindings_v1411_write__xlink.roleType)
    __role._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 48, 1)
    __role._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 114, 2)
    
    role = property(__role.value, __role.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}arcrole uses Python identifier arcrole
    __arcrole = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'arcrole'), 'arcrole', '__httpwww_opengis_netgml3_2_DirectedTopoSolidPropertyType_httpwww_w3_org1999xlinkarcrole', _ImportedBinding_bindings_v1411_write__xlink.arcroleType)
    __arcrole._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 56, 1)
    __arcrole._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 115, 2)
    
    arcrole = property(__arcrole.value, __arcrole.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}title uses Python identifier title
    __title = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'title'), 'title', '__httpwww_opengis_netgml3_2_DirectedTopoSolidPropertyType_httpwww_w3_org1999xlinktitle', _ImportedBinding_bindings_v1411_write__xlink.titleAttrType)
    __title._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 64, 1)
    __title._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 116, 2)
    
    title = property(__title.value, __title.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}show uses Python identifier show
    __show = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'show'), 'show', '__httpwww_opengis_netgml3_2_DirectedTopoSolidPropertyType_httpwww_w3_org1999xlinkshow', _ImportedBinding_bindings_v1411_write__xlink.showType)
    __show._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 70, 1)
    __show._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 117, 2)
    
    show = property(__show.value, __show.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}actuate uses Python identifier actuate
    __actuate = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'actuate'), 'actuate', '__httpwww_opengis_netgml3_2_DirectedTopoSolidPropertyType_httpwww_w3_org1999xlinkactuate', _ImportedBinding_bindings_v1411_write__xlink.actuateType)
    __actuate._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 82, 1)
    __actuate._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 118, 2)
    
    actuate = property(__actuate.value, __actuate.set, None, None)

    _ElementMap.update({
        __TopoSolid.name() : __TopoSolid
    })
    _AttributeMap.update({
        __remoteSchema.name() : __remoteSchema,
        __nilReason.name() : __nilReason,
        __owns.name() : __owns,
        __orientation.name() : __orientation,
        __type.name() : __type,
        __href.name() : __href,
        __role.name() : __role,
        __arcrole.name() : __arcrole,
        __title.name() : __title,
        __show.name() : __show,
        __actuate.name() : __actuate
    })
_module_typeBindings.DirectedTopoSolidPropertyType = DirectedTopoSolidPropertyType
_Namespace_gml.addCategoryObject('typeBinding', 'DirectedTopoSolidPropertyType', DirectedTopoSolidPropertyType)


# Complex type {http://www.opengis.net/gml/3.2}TopoPointType with content type ELEMENT_ONLY
class TopoPointType (AbstractTopologyType):
    """Complex type {http://www.opengis.net/gml/3.2}TopoPointType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'TopoPointType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/topology.xsd', 215, 2)
    _ElementMap = AbstractTopologyType._ElementMap.copy()
    _AttributeMap = AbstractTopologyType._AttributeMap.copy()
    # Base type is AbstractTopologyType
    
    # Element metaDataProperty ({http://www.opengis.net/gml/3.2}metaDataProperty) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element description ({http://www.opengis.net/gml/3.2}description) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element descriptionReference ({http://www.opengis.net/gml/3.2}descriptionReference) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element name ({http://www.opengis.net/gml/3.2}name) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element identifier ({http://www.opengis.net/gml/3.2}identifier) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element {http://www.opengis.net/gml/3.2}directedNode uses Python identifier directedNode
    __directedNode = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'directedNode'), 'directedNode', '__httpwww_opengis_netgml3_2_TopoPointType_httpwww_opengis_netgml3_2directedNode', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/topology.xsd', 91, 2), )

    
    directedNode = property(__directedNode.value, __directedNode.set, None, 'A gml:directedNode property element describes the boundary of topology edges and is used in the support of topological point features via the gml:TopoPoint expression, see below. The orientation attribute of type gml:SignType expresses the sense in which the included node is used: start ("-") or end ("+") node.')

    
    # Attribute id inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    _ElementMap.update({
        __directedNode.name() : __directedNode
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.TopoPointType = TopoPointType
_Namespace_gml.addCategoryObject('typeBinding', 'TopoPointType', TopoPointType)


# Complex type {http://www.opengis.net/gml/3.2}TopoCurveType with content type ELEMENT_ONLY
class TopoCurveType (AbstractTopologyType):
    """Complex type {http://www.opengis.net/gml/3.2}TopoCurveType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'TopoCurveType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/topology.xsd', 240, 2)
    _ElementMap = AbstractTopologyType._ElementMap.copy()
    _AttributeMap = AbstractTopologyType._AttributeMap.copy()
    # Base type is AbstractTopologyType
    
    # Element metaDataProperty ({http://www.opengis.net/gml/3.2}metaDataProperty) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element description ({http://www.opengis.net/gml/3.2}description) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element descriptionReference ({http://www.opengis.net/gml/3.2}descriptionReference) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element name ({http://www.opengis.net/gml/3.2}name) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element identifier ({http://www.opengis.net/gml/3.2}identifier) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element {http://www.opengis.net/gml/3.2}directedEdge uses Python identifier directedEdge
    __directedEdge = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'directedEdge'), 'directedEdge', '__httpwww_opengis_netgml3_2_TopoCurveType_httpwww_opengis_netgml3_2directedEdge', True, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/topology.xsd', 126, 2), )

    
    directedEdge = property(__directedEdge.value, __directedEdge.set, None, 'A gml:directedEdge property element describes the boundary of topology faces, the coBoundary of topology nodes and is used in the support of topological line features via the gml:TopoCurve expression, see below. The orientation attribute of type gml:SignType expresses the sense in which the included edge is used, i.e. forward or reverse.')

    
    # Attribute id inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Attribute aggregationType uses Python identifier aggregationType
    __aggregationType = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'aggregationType'), 'aggregationType', '__httpwww_opengis_netgml3_2_TopoCurveType_aggregationType', _module_typeBindings.AggregationType)
    __aggregationType._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 158, 2)
    __aggregationType._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 158, 2)
    
    aggregationType = property(__aggregationType.value, __aggregationType.set, None, None)

    _ElementMap.update({
        __directedEdge.name() : __directedEdge
    })
    _AttributeMap.update({
        __aggregationType.name() : __aggregationType
    })
_module_typeBindings.TopoCurveType = TopoCurveType
_Namespace_gml.addCategoryObject('typeBinding', 'TopoCurveType', TopoCurveType)


# Complex type {http://www.opengis.net/gml/3.2}TopoSurfaceType with content type ELEMENT_ONLY
class TopoSurfaceType (AbstractTopologyType):
    """Complex type {http://www.opengis.net/gml/3.2}TopoSurfaceType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'TopoSurfaceType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/topology.xsd', 267, 2)
    _ElementMap = AbstractTopologyType._ElementMap.copy()
    _AttributeMap = AbstractTopologyType._AttributeMap.copy()
    # Base type is AbstractTopologyType
    
    # Element metaDataProperty ({http://www.opengis.net/gml/3.2}metaDataProperty) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element description ({http://www.opengis.net/gml/3.2}description) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element descriptionReference ({http://www.opengis.net/gml/3.2}descriptionReference) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element name ({http://www.opengis.net/gml/3.2}name) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element identifier ({http://www.opengis.net/gml/3.2}identifier) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element {http://www.opengis.net/gml/3.2}directedFace uses Python identifier directedFace
    __directedFace = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'directedFace'), 'directedFace', '__httpwww_opengis_netgml3_2_TopoSurfaceType_httpwww_opengis_netgml3_2directedFace', True, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/topology.xsd', 165, 2), )

    
    directedFace = property(__directedFace.value, __directedFace.set, None, 'The gml:directedFace property element describes the boundary of topology solids, in the coBoundary of topology edges and is used in the support of surface features via the gml:TopoSurface expression, see below. The orientation attribute of type gml:SignType expresses the sense in which the included face is used i.e. inward or outward with respect to the surface normal in any geometric realisation.')

    
    # Attribute id inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Attribute aggregationType uses Python identifier aggregationType
    __aggregationType = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'aggregationType'), 'aggregationType', '__httpwww_opengis_netgml3_2_TopoSurfaceType_aggregationType', _module_typeBindings.AggregationType)
    __aggregationType._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 158, 2)
    __aggregationType._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 158, 2)
    
    aggregationType = property(__aggregationType.value, __aggregationType.set, None, None)

    _ElementMap.update({
        __directedFace.name() : __directedFace
    })
    _AttributeMap.update({
        __aggregationType.name() : __aggregationType
    })
_module_typeBindings.TopoSurfaceType = TopoSurfaceType
_Namespace_gml.addCategoryObject('typeBinding', 'TopoSurfaceType', TopoSurfaceType)


# Complex type {http://www.opengis.net/gml/3.2}TopoVolumeType with content type ELEMENT_ONLY
class TopoVolumeType (AbstractTopologyType):
    """Complex type {http://www.opengis.net/gml/3.2}TopoVolumeType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'TopoVolumeType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/topology.xsd', 293, 2)
    _ElementMap = AbstractTopologyType._ElementMap.copy()
    _AttributeMap = AbstractTopologyType._AttributeMap.copy()
    # Base type is AbstractTopologyType
    
    # Element metaDataProperty ({http://www.opengis.net/gml/3.2}metaDataProperty) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element description ({http://www.opengis.net/gml/3.2}description) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element descriptionReference ({http://www.opengis.net/gml/3.2}descriptionReference) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element name ({http://www.opengis.net/gml/3.2}name) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element identifier ({http://www.opengis.net/gml/3.2}identifier) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element {http://www.opengis.net/gml/3.2}directedTopoSolid uses Python identifier directedTopoSolid
    __directedTopoSolid = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'directedTopoSolid'), 'directedTopoSolid', '__httpwww_opengis_netgml3_2_TopoVolumeType_httpwww_opengis_netgml3_2directedTopoSolid', True, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/topology.xsd', 202, 2), )

    
    directedTopoSolid = property(__directedTopoSolid.value, __directedTopoSolid.set, None, 'The gml:directedSolid property element describes the coBoundary of topology faces and is used in the support of volume features via the gml:TopoVolume expression, see below. The orientation attribute of type gml:SignType expresses the sense in which the included solid appears in the face coboundary. In the context of a gml:TopoVolume the orientation attribute has no meaning.')

    
    # Attribute id inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Attribute aggregationType uses Python identifier aggregationType
    __aggregationType = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'aggregationType'), 'aggregationType', '__httpwww_opengis_netgml3_2_TopoVolumeType_aggregationType', _module_typeBindings.AggregationType)
    __aggregationType._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 158, 2)
    __aggregationType._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 158, 2)
    
    aggregationType = property(__aggregationType.value, __aggregationType.set, None, None)

    _ElementMap.update({
        __directedTopoSolid.name() : __directedTopoSolid
    })
    _AttributeMap.update({
        __aggregationType.name() : __aggregationType
    })
_module_typeBindings.TopoVolumeType = TopoVolumeType
_Namespace_gml.addCategoryObject('typeBinding', 'TopoVolumeType', TopoVolumeType)


# Complex type {http://www.opengis.net/gml/3.2}TopoComplexType with content type ELEMENT_ONLY
class TopoComplexType (AbstractTopologyType):
    """Complex type {http://www.opengis.net/gml/3.2}TopoComplexType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'TopoComplexType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/topology.xsd', 319, 2)
    _ElementMap = AbstractTopologyType._ElementMap.copy()
    _AttributeMap = AbstractTopologyType._AttributeMap.copy()
    # Base type is AbstractTopologyType
    
    # Element metaDataProperty ({http://www.opengis.net/gml/3.2}metaDataProperty) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element description ({http://www.opengis.net/gml/3.2}description) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element descriptionReference ({http://www.opengis.net/gml/3.2}descriptionReference) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element name ({http://www.opengis.net/gml/3.2}name) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element identifier ({http://www.opengis.net/gml/3.2}identifier) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element {http://www.opengis.net/gml/3.2}subComplex uses Python identifier subComplex
    __subComplex = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'subComplex'), 'subComplex', '__httpwww_opengis_netgml3_2_TopoComplexType_httpwww_opengis_netgml3_2subComplex', True, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/topology.xsd', 342, 2), )

    
    subComplex = property(__subComplex.value, __subComplex.set, None, 'The property elements gml:subComplex, gml:superComplex and gml:maximalComplex provide an encoding for relationships between topology complexes as described for gml:TopoComplex above.')

    
    # Element {http://www.opengis.net/gml/3.2}superComplex uses Python identifier superComplex
    __superComplex = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'superComplex'), 'superComplex', '__httpwww_opengis_netgml3_2_TopoComplexType_httpwww_opengis_netgml3_2superComplex', True, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/topology.xsd', 347, 2), )

    
    superComplex = property(__superComplex.value, __superComplex.set, None, 'The property elements gml:subComplex, gml:superComplex and gml:maximalComplex provide an encoding for relationships between topology complexes as described for gml:TopoComplex above.')

    
    # Element {http://www.opengis.net/gml/3.2}maximalComplex uses Python identifier maximalComplex
    __maximalComplex = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'maximalComplex'), 'maximalComplex', '__httpwww_opengis_netgml3_2_TopoComplexType_httpwww_opengis_netgml3_2maximalComplex', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/topology.xsd', 352, 2), )

    
    maximalComplex = property(__maximalComplex.value, __maximalComplex.set, None, 'The property elements gml:subComplex, gml:superComplex and gml:maximalComplex provide an encoding for relationships between topology complexes as described for gml:TopoComplex above.')

    
    # Element {http://www.opengis.net/gml/3.2}topoPrimitiveMember uses Python identifier topoPrimitiveMember
    __topoPrimitiveMember = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'topoPrimitiveMember'), 'topoPrimitiveMember', '__httpwww_opengis_netgml3_2_TopoComplexType_httpwww_opengis_netgml3_2topoPrimitiveMember', True, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/topology.xsd', 357, 2), )

    
    topoPrimitiveMember = property(__topoPrimitiveMember.value, __topoPrimitiveMember.set, None, 'The gml:topoPrimitiveMember property element encodes for the relationship between a topology complex and a single topology primitive.')

    
    # Element {http://www.opengis.net/gml/3.2}topoPrimitiveMembers uses Python identifier topoPrimitiveMembers
    __topoPrimitiveMembers = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'topoPrimitiveMembers'), 'topoPrimitiveMembers', '__httpwww_opengis_netgml3_2_TopoComplexType_httpwww_opengis_netgml3_2topoPrimitiveMembers', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/topology.xsd', 369, 2), )

    
    topoPrimitiveMembers = property(__topoPrimitiveMembers.value, __topoPrimitiveMembers.set, None, 'The gml:topoPrimitiveMembers property element encodes the relationship between a topology complex and an arbitrary number of topology primitives.')

    
    # Attribute id inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Attribute aggregationType uses Python identifier aggregationType
    __aggregationType = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'aggregationType'), 'aggregationType', '__httpwww_opengis_netgml3_2_TopoComplexType_aggregationType', _module_typeBindings.AggregationType)
    __aggregationType._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 158, 2)
    __aggregationType._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 158, 2)
    
    aggregationType = property(__aggregationType.value, __aggregationType.set, None, None)

    
    # Attribute isMaximal uses Python identifier isMaximal
    __isMaximal = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'isMaximal'), 'isMaximal', '__httpwww_opengis_netgml3_2_TopoComplexType_isMaximal', pyxb.binding.datatypes.boolean, unicode_default='false')
    __isMaximal._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/topology.xsd', 329, 8)
    __isMaximal._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/topology.xsd', 329, 8)
    
    isMaximal = property(__isMaximal.value, __isMaximal.set, None, None)

    _ElementMap.update({
        __subComplex.name() : __subComplex,
        __superComplex.name() : __superComplex,
        __maximalComplex.name() : __maximalComplex,
        __topoPrimitiveMember.name() : __topoPrimitiveMember,
        __topoPrimitiveMembers.name() : __topoPrimitiveMembers
    })
    _AttributeMap.update({
        __aggregationType.name() : __aggregationType,
        __isMaximal.name() : __isMaximal
    })
_module_typeBindings.TopoComplexType = TopoComplexType
_Namespace_gml.addCategoryObject('typeBinding', 'TopoComplexType', TopoComplexType)


# Complex type {http://www.opengis.net/gml/3.2}TopoPrimitiveMemberType with content type ELEMENT_ONLY
class TopoPrimitiveMemberType (pyxb.binding.basis.complexTypeDefinition):
    """Complex type {http://www.opengis.net/gml/3.2}TopoPrimitiveMemberType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'TopoPrimitiveMemberType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/topology.xsd', 362, 2)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.opengis.net/gml/3.2}AbstractTopoPrimitive uses Python identifier AbstractTopoPrimitive
    __AbstractTopoPrimitive = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractTopoPrimitive'), 'AbstractTopoPrimitive', '__httpwww_opengis_netgml3_2_TopoPrimitiveMemberType_httpwww_opengis_netgml3_2AbstractTopoPrimitive', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/topology.xsd', 31, 2), )

    
    AbstractTopoPrimitive = property(__AbstractTopoPrimitive.value, __AbstractTopoPrimitive.set, None, 'gml:AbstractTopoPrimitive acts as the base type for all topological primitives. Topology primitives are the atomic (smallest possible) units of a topology complex. \nEach topology primitive may contain references to other topology primitives of codimension 2 or more (gml:isolated). Conversely, nodes may have faces as containers and nodes and edges may have solids as containers (gml:container).')

    
    # Attribute {http://www.opengis.net/gml/3.2}remoteSchema uses Python identifier remoteSchema
    __remoteSchema = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gml, 'remoteSchema'), 'remoteSchema', '__httpwww_opengis_netgml3_2_TopoPrimitiveMemberType_httpwww_opengis_netgml3_2remoteSchema', pyxb.binding.datatypes.anyURI)
    __remoteSchema._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 638, 1)
    __remoteSchema._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 52, 2)
    
    remoteSchema = property(__remoteSchema.value, __remoteSchema.set, None, '')

    
    # Attribute nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'nilReason'), 'nilReason', '__httpwww_opengis_netgml3_2_TopoPrimitiveMemberType_nilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 51, 2)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 51, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    
    # Attribute owns uses Python identifier owns
    __owns = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'owns'), 'owns', '__httpwww_opengis_netgml3_2_TopoPrimitiveMemberType_owns', pyxb.binding.datatypes.boolean, unicode_default='false')
    __owns._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 79, 2)
    __owns._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 79, 2)
    
    owns = property(__owns.value, __owns.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}type uses Python identifier type
    __type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'type'), 'type', '__httpwww_opengis_netgml3_2_TopoPrimitiveMemberType_httpwww_w3_org1999xlinktype', _ImportedBinding_bindings_v1411_write__xlink.typeType, fixed=True, unicode_default='simple')
    __type._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 29, 1)
    __type._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 112, 2)
    
    type = property(__type.value, __type.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}href uses Python identifier href
    __href = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'href'), 'href', '__httpwww_opengis_netgml3_2_TopoPrimitiveMemberType_httpwww_w3_org1999xlinkhref', _ImportedBinding_bindings_v1411_write__xlink.hrefType)
    __href._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 42, 1)
    __href._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 113, 2)
    
    href = property(__href.value, __href.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}role uses Python identifier role
    __role = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'role'), 'role', '__httpwww_opengis_netgml3_2_TopoPrimitiveMemberType_httpwww_w3_org1999xlinkrole', _ImportedBinding_bindings_v1411_write__xlink.roleType)
    __role._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 48, 1)
    __role._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 114, 2)
    
    role = property(__role.value, __role.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}arcrole uses Python identifier arcrole
    __arcrole = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'arcrole'), 'arcrole', '__httpwww_opengis_netgml3_2_TopoPrimitiveMemberType_httpwww_w3_org1999xlinkarcrole', _ImportedBinding_bindings_v1411_write__xlink.arcroleType)
    __arcrole._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 56, 1)
    __arcrole._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 115, 2)
    
    arcrole = property(__arcrole.value, __arcrole.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}title uses Python identifier title
    __title = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'title'), 'title', '__httpwww_opengis_netgml3_2_TopoPrimitiveMemberType_httpwww_w3_org1999xlinktitle', _ImportedBinding_bindings_v1411_write__xlink.titleAttrType)
    __title._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 64, 1)
    __title._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 116, 2)
    
    title = property(__title.value, __title.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}show uses Python identifier show
    __show = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'show'), 'show', '__httpwww_opengis_netgml3_2_TopoPrimitiveMemberType_httpwww_w3_org1999xlinkshow', _ImportedBinding_bindings_v1411_write__xlink.showType)
    __show._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 70, 1)
    __show._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 117, 2)
    
    show = property(__show.value, __show.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}actuate uses Python identifier actuate
    __actuate = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'actuate'), 'actuate', '__httpwww_opengis_netgml3_2_TopoPrimitiveMemberType_httpwww_w3_org1999xlinkactuate', _ImportedBinding_bindings_v1411_write__xlink.actuateType)
    __actuate._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 82, 1)
    __actuate._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 118, 2)
    
    actuate = property(__actuate.value, __actuate.set, None, None)

    _ElementMap.update({
        __AbstractTopoPrimitive.name() : __AbstractTopoPrimitive
    })
    _AttributeMap.update({
        __remoteSchema.name() : __remoteSchema,
        __nilReason.name() : __nilReason,
        __owns.name() : __owns,
        __type.name() : __type,
        __href.name() : __href,
        __role.name() : __role,
        __arcrole.name() : __arcrole,
        __title.name() : __title,
        __show.name() : __show,
        __actuate.name() : __actuate
    })
_module_typeBindings.TopoPrimitiveMemberType = TopoPrimitiveMemberType
_Namespace_gml.addCategoryObject('typeBinding', 'TopoPrimitiveMemberType', TopoPrimitiveMemberType)


# Complex type {http://www.opengis.net/gml/3.2}TopoComplexPropertyType with content type ELEMENT_ONLY
class TopoComplexPropertyType (pyxb.binding.basis.complexTypeDefinition):
    """Complex type {http://www.opengis.net/gml/3.2}TopoComplexPropertyType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'TopoComplexPropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/topology.xsd', 380, 2)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.opengis.net/gml/3.2}TopoComplex uses Python identifier TopoComplex
    __TopoComplex = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'TopoComplex'), 'TopoComplex', '__httpwww_opengis_netgml3_2_TopoComplexPropertyType_httpwww_opengis_netgml3_2TopoComplex', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/topology.xsd', 334, 2), )

    
    TopoComplex = property(__TopoComplex.value, __TopoComplex.set, None, 'gml:TopoComplex is a collection of topological primitives.\nEach complex holds a reference to its maximal complex (gml:maximalComplex) and optionally to sub- or super-complexes (gml:subComplex, gml:superComplex). \nA topology complex contains its primitive and sub-complex members.\n')

    
    # Attribute {http://www.opengis.net/gml/3.2}remoteSchema uses Python identifier remoteSchema
    __remoteSchema = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gml, 'remoteSchema'), 'remoteSchema', '__httpwww_opengis_netgml3_2_TopoComplexPropertyType_httpwww_opengis_netgml3_2remoteSchema', pyxb.binding.datatypes.anyURI)
    __remoteSchema._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 638, 1)
    __remoteSchema._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 52, 2)
    
    remoteSchema = property(__remoteSchema.value, __remoteSchema.set, None, '')

    
    # Attribute nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'nilReason'), 'nilReason', '__httpwww_opengis_netgml3_2_TopoComplexPropertyType_nilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 51, 2)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 51, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}type uses Python identifier type
    __type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'type'), 'type', '__httpwww_opengis_netgml3_2_TopoComplexPropertyType_httpwww_w3_org1999xlinktype', _ImportedBinding_bindings_v1411_write__xlink.typeType, fixed=True, unicode_default='simple')
    __type._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 29, 1)
    __type._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 112, 2)
    
    type = property(__type.value, __type.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}href uses Python identifier href
    __href = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'href'), 'href', '__httpwww_opengis_netgml3_2_TopoComplexPropertyType_httpwww_w3_org1999xlinkhref', _ImportedBinding_bindings_v1411_write__xlink.hrefType)
    __href._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 42, 1)
    __href._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 113, 2)
    
    href = property(__href.value, __href.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}role uses Python identifier role
    __role = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'role'), 'role', '__httpwww_opengis_netgml3_2_TopoComplexPropertyType_httpwww_w3_org1999xlinkrole', _ImportedBinding_bindings_v1411_write__xlink.roleType)
    __role._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 48, 1)
    __role._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 114, 2)
    
    role = property(__role.value, __role.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}arcrole uses Python identifier arcrole
    __arcrole = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'arcrole'), 'arcrole', '__httpwww_opengis_netgml3_2_TopoComplexPropertyType_httpwww_w3_org1999xlinkarcrole', _ImportedBinding_bindings_v1411_write__xlink.arcroleType)
    __arcrole._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 56, 1)
    __arcrole._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 115, 2)
    
    arcrole = property(__arcrole.value, __arcrole.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}title uses Python identifier title
    __title = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'title'), 'title', '__httpwww_opengis_netgml3_2_TopoComplexPropertyType_httpwww_w3_org1999xlinktitle', _ImportedBinding_bindings_v1411_write__xlink.titleAttrType)
    __title._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 64, 1)
    __title._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 116, 2)
    
    title = property(__title.value, __title.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}show uses Python identifier show
    __show = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'show'), 'show', '__httpwww_opengis_netgml3_2_TopoComplexPropertyType_httpwww_w3_org1999xlinkshow', _ImportedBinding_bindings_v1411_write__xlink.showType)
    __show._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 70, 1)
    __show._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 117, 2)
    
    show = property(__show.value, __show.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}actuate uses Python identifier actuate
    __actuate = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'actuate'), 'actuate', '__httpwww_opengis_netgml3_2_TopoComplexPropertyType_httpwww_w3_org1999xlinkactuate', _ImportedBinding_bindings_v1411_write__xlink.actuateType)
    __actuate._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 82, 1)
    __actuate._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 118, 2)
    
    actuate = property(__actuate.value, __actuate.set, None, None)

    _ElementMap.update({
        __TopoComplex.name() : __TopoComplex
    })
    _AttributeMap.update({
        __remoteSchema.name() : __remoteSchema,
        __nilReason.name() : __nilReason,
        __type.name() : __type,
        __href.name() : __href,
        __role.name() : __role,
        __arcrole.name() : __arcrole,
        __title.name() : __title,
        __show.name() : __show,
        __actuate.name() : __actuate
    })
_module_typeBindings.TopoComplexPropertyType = TopoComplexPropertyType
_Namespace_gml.addCategoryObject('typeBinding', 'TopoComplexPropertyType', TopoComplexPropertyType)


# Complex type {http://www.opengis.net/gml/3.2}UnitOfMeasureType with content type EMPTY
class UnitOfMeasureType (pyxb.binding.basis.complexTypeDefinition):
    """Complex type {http://www.opengis.net/gml/3.2}UnitOfMeasureType with content type EMPTY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_EMPTY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'UnitOfMeasureType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/units.xsd', 26, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Attribute uom uses Python identifier uom
    __uom = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'uom'), 'uom', '__httpwww_opengis_netgml3_2_UnitOfMeasureType_uom', _module_typeBindings.UomIdentifier, required=True)
    __uom._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/units.xsd', 28, 2)
    __uom._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/units.xsd', 28, 2)
    
    uom = property(__uom.value, __uom.set, None, None)

    _ElementMap.update({
        
    })
    _AttributeMap.update({
        __uom.name() : __uom
    })
_module_typeBindings.UnitOfMeasureType = UnitOfMeasureType
_Namespace_gml.addCategoryObject('typeBinding', 'UnitOfMeasureType', UnitOfMeasureType)


# Complex type [anonymous] with content type SIMPLE
class CTD_ANON_9 (pyxb.binding.basis.complexTypeDefinition):
    """Complex type [anonymous] with content type SIMPLE"""
    _TypeDefinition = pyxb.binding.datatypes.boolean
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_SIMPLE
    _Abstract = False
    _ExpandedName = None
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/valueObjects.xsd', 25, 2)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.boolean
    
    # Attribute nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'nilReason'), 'nilReason', '__httpwww_opengis_netgml3_2_CTD_ANON_9_nilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/valueObjects.xsd', 28, 5)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/valueObjects.xsd', 28, 5)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    _ElementMap.update({
        
    })
    _AttributeMap.update({
        __nilReason.name() : __nilReason
    })
_module_typeBindings.CTD_ANON_9 = CTD_ANON_9


# Complex type [anonymous] with content type SIMPLE
class CTD_ANON_10 (CodeType):
    """A gml:Category has an optional XML attribute codeSpace, whose value is a URI which identifies a dictionary, codelist or authority for the term."""
    _TypeDefinition = pyxb.binding.datatypes.string
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_SIMPLE
    _Abstract = False
    _ExpandedName = None
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/valueObjects.xsd', 38, 2)
    _ElementMap = CodeType._ElementMap.copy()
    _AttributeMap = CodeType._AttributeMap.copy()
    # Base type is CodeType
    
    # Attribute codeSpace inherited from {http://www.opengis.net/gml/3.2}CodeType
    
    # Attribute nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'nilReason'), 'nilReason', '__httpwww_opengis_netgml3_2_CTD_ANON_10_nilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/valueObjects.xsd', 41, 5)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/valueObjects.xsd', 41, 5)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    _ElementMap.update({
        
    })
    _AttributeMap.update({
        __nilReason.name() : __nilReason
    })
_module_typeBindings.CTD_ANON_10 = CTD_ANON_10


# Complex type [anonymous] with content type SIMPLE
class CTD_ANON_11 (pyxb.binding.basis.complexTypeDefinition):
    """Complex type [anonymous] with content type SIMPLE"""
    _TypeDefinition = pyxb.binding.datatypes.integer
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_SIMPLE
    _Abstract = False
    _ExpandedName = None
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/valueObjects.xsd', 48, 2)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.integer
    
    # Attribute nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'nilReason'), 'nilReason', '__httpwww_opengis_netgml3_2_CTD_ANON_11_nilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/valueObjects.xsd', 51, 5)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/valueObjects.xsd', 51, 5)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    _ElementMap.update({
        
    })
    _AttributeMap.update({
        __nilReason.name() : __nilReason
    })
_module_typeBindings.CTD_ANON_11 = CTD_ANON_11


# Complex type {http://www.opengis.net/gml/3.2}ValuePropertyType with content type ELEMENT_ONLY
class ValuePropertyType (pyxb.binding.basis.complexTypeDefinition):
    """Complex type {http://www.opengis.net/gml/3.2}ValuePropertyType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'ValuePropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/valueObjects.xsd', 107, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.opengis.net/gml/3.2}Null uses Python identifier Null
    __Null = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'Null'), 'Null', '__httpwww_opengis_netgml3_2_ValuePropertyType_httpwww_opengis_netgml3_2Null', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 13, 1), )

    
    Null = property(__Null.value, __Null.set, None, '')

    
    # Element {http://www.opengis.net/gml/3.2}AbstractGeometry uses Python identifier AbstractGeometry
    __AbstractGeometry = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractGeometry'), 'AbstractGeometry', '__httpwww_opengis_netgml3_2_ValuePropertyType_httpwww_opengis_netgml3_2AbstractGeometry', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic0d1d.xsd', 50, 1), )

    
    AbstractGeometry = property(__AbstractGeometry.value, __AbstractGeometry.set, None, 'The AbstractGeometry element is the abstract head of the substitution group for all geometry elements of GML. This includes pre-defined and user-defined geometry elements. Any geometry element shall be a direct or indirect extension/restriction of AbstractGeometryType and shall be directly or indirectly in the substitution group of AbstractGeometry.')

    
    # Element {http://www.opengis.net/gml/3.2}AbstractTimeObject uses Python identifier AbstractTimeObject
    __AbstractTimeObject = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractTimeObject'), 'AbstractTimeObject', '__httpwww_opengis_netgml3_2_ValuePropertyType_httpwww_opengis_netgml3_2AbstractTimeObject', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporal.xsd', 18, 1), )

    
    AbstractTimeObject = property(__AbstractTimeObject.value, __AbstractTimeObject.set, None, 'gml:AbstractTimeObject acts as the head of a substitution group for all temporal primitives and complexes.')

    
    # Element {http://www.opengis.net/gml/3.2}AbstractValue uses Python identifier AbstractValue
    __AbstractValue = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractValue'), 'AbstractValue', '__httpwww_opengis_netgml3_2_ValuePropertyType_httpwww_opengis_netgml3_2AbstractValue', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/valueObjects.xsd', 70, 1), )

    
    AbstractValue = property(__AbstractValue.value, __AbstractValue.set, None, 'gml:AbstractValue is an abstract element which acts as the head of a substitution group which contains gml:AbstractScalarValue, gml:AbstractScalarValueList, gml:CompositeValue and gml:ValueExtent, and (transitively) the elements in their substitution groups.\nThese elements may be used in an application schema as variables, so that in an XML instance document any member of its substitution group may occur.')

    
    # Attribute {http://www.opengis.net/gml/3.2}remoteSchema uses Python identifier remoteSchema
    __remoteSchema = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gml, 'remoteSchema'), 'remoteSchema', '__httpwww_opengis_netgml3_2_ValuePropertyType_httpwww_opengis_netgml3_2remoteSchema', pyxb.binding.datatypes.anyURI)
    __remoteSchema._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 638, 1)
    __remoteSchema._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 52, 2)
    
    remoteSchema = property(__remoteSchema.value, __remoteSchema.set, None, '')

    
    # Attribute nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'nilReason'), 'nilReason', '__httpwww_opengis_netgml3_2_ValuePropertyType_nilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 51, 2)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 51, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    
    # Attribute owns uses Python identifier owns
    __owns = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'owns'), 'owns', '__httpwww_opengis_netgml3_2_ValuePropertyType_owns', pyxb.binding.datatypes.boolean, unicode_default='false')
    __owns._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 79, 2)
    __owns._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 79, 2)
    
    owns = property(__owns.value, __owns.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}type uses Python identifier type
    __type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'type'), 'type', '__httpwww_opengis_netgml3_2_ValuePropertyType_httpwww_w3_org1999xlinktype', _ImportedBinding_bindings_v1411_write__xlink.typeType, fixed=True, unicode_default='simple')
    __type._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 29, 1)
    __type._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 112, 2)
    
    type = property(__type.value, __type.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}href uses Python identifier href
    __href = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'href'), 'href', '__httpwww_opengis_netgml3_2_ValuePropertyType_httpwww_w3_org1999xlinkhref', _ImportedBinding_bindings_v1411_write__xlink.hrefType)
    __href._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 42, 1)
    __href._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 113, 2)
    
    href = property(__href.value, __href.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}role uses Python identifier role
    __role = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'role'), 'role', '__httpwww_opengis_netgml3_2_ValuePropertyType_httpwww_w3_org1999xlinkrole', _ImportedBinding_bindings_v1411_write__xlink.roleType)
    __role._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 48, 1)
    __role._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 114, 2)
    
    role = property(__role.value, __role.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}arcrole uses Python identifier arcrole
    __arcrole = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'arcrole'), 'arcrole', '__httpwww_opengis_netgml3_2_ValuePropertyType_httpwww_w3_org1999xlinkarcrole', _ImportedBinding_bindings_v1411_write__xlink.arcroleType)
    __arcrole._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 56, 1)
    __arcrole._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 115, 2)
    
    arcrole = property(__arcrole.value, __arcrole.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}title uses Python identifier title
    __title = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'title'), 'title', '__httpwww_opengis_netgml3_2_ValuePropertyType_httpwww_w3_org1999xlinktitle', _ImportedBinding_bindings_v1411_write__xlink.titleAttrType)
    __title._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 64, 1)
    __title._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 116, 2)
    
    title = property(__title.value, __title.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}show uses Python identifier show
    __show = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'show'), 'show', '__httpwww_opengis_netgml3_2_ValuePropertyType_httpwww_w3_org1999xlinkshow', _ImportedBinding_bindings_v1411_write__xlink.showType)
    __show._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 70, 1)
    __show._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 117, 2)
    
    show = property(__show.value, __show.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}actuate uses Python identifier actuate
    __actuate = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'actuate'), 'actuate', '__httpwww_opengis_netgml3_2_ValuePropertyType_httpwww_w3_org1999xlinkactuate', _ImportedBinding_bindings_v1411_write__xlink.actuateType)
    __actuate._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 82, 1)
    __actuate._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 118, 2)
    
    actuate = property(__actuate.value, __actuate.set, None, None)

    _ElementMap.update({
        __Null.name() : __Null,
        __AbstractGeometry.name() : __AbstractGeometry,
        __AbstractTimeObject.name() : __AbstractTimeObject,
        __AbstractValue.name() : __AbstractValue
    })
    _AttributeMap.update({
        __remoteSchema.name() : __remoteSchema,
        __nilReason.name() : __nilReason,
        __owns.name() : __owns,
        __type.name() : __type,
        __href.name() : __href,
        __role.name() : __role,
        __arcrole.name() : __arcrole,
        __title.name() : __title,
        __show.name() : __show,
        __actuate.name() : __actuate
    })
_module_typeBindings.ValuePropertyType = ValuePropertyType
_Namespace_gml.addCategoryObject('typeBinding', 'ValuePropertyType', ValuePropertyType)


# Complex type {http://www.opengis.net/gml/3.2}ValueArrayType with content type ELEMENT_ONLY
class ValueArrayType (CompositeValueType):
    """Complex type {http://www.opengis.net/gml/3.2}ValueArrayType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'ValueArrayType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/valueObjects.xsd', 148, 1)
    _ElementMap = CompositeValueType._ElementMap.copy()
    _AttributeMap = CompositeValueType._AttributeMap.copy()
    # Base type is CompositeValueType
    
    # Element metaDataProperty ({http://www.opengis.net/gml/3.2}metaDataProperty) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element description ({http://www.opengis.net/gml/3.2}description) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element descriptionReference ({http://www.opengis.net/gml/3.2}descriptionReference) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element name ({http://www.opengis.net/gml/3.2}name) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element identifier ({http://www.opengis.net/gml/3.2}identifier) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element valueComponent ({http://www.opengis.net/gml/3.2}valueComponent) inherited from {http://www.opengis.net/gml/3.2}CompositeValueType
    
    # Element valueComponents ({http://www.opengis.net/gml/3.2}valueComponents) inherited from {http://www.opengis.net/gml/3.2}CompositeValueType
    
    # Attribute id inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Attribute aggregationType inherited from {http://www.opengis.net/gml/3.2}CompositeValueType
    
    # Attribute codeSpace uses Python identifier codeSpace
    __codeSpace = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'codeSpace'), 'codeSpace', '__httpwww_opengis_netgml3_2_ValueArrayType_codeSpace', pyxb.binding.datatypes.anyURI)
    __codeSpace._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/valueObjects.xsd', 156, 2)
    __codeSpace._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/valueObjects.xsd', 156, 2)
    
    codeSpace = property(__codeSpace.value, __codeSpace.set, None, None)

    
    # Attribute uom uses Python identifier uom
    __uom = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'uom'), 'uom', '__httpwww_opengis_netgml3_2_ValueArrayType_uom', _module_typeBindings.UomIdentifier)
    __uom._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/valueObjects.xsd', 157, 2)
    __uom._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/valueObjects.xsd', 157, 2)
    
    uom = property(__uom.value, __uom.set, None, None)

    _ElementMap.update({
        
    })
    _AttributeMap.update({
        __codeSpace.name() : __codeSpace,
        __uom.name() : __uom
    })
_module_typeBindings.ValueArrayType = ValueArrayType
_Namespace_gml.addCategoryObject('typeBinding', 'ValueArrayType', ValueArrayType)


# Complex type {http://www.opengis.net/gml/3.2}BooleanPropertyType with content type ELEMENT_ONLY
class BooleanPropertyType (pyxb.binding.basis.complexTypeDefinition):
    """Complex type {http://www.opengis.net/gml/3.2}BooleanPropertyType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'BooleanPropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/valueObjects.xsd', 181, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.opengis.net/gml/3.2}Boolean uses Python identifier Boolean
    __Boolean = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'Boolean'), 'Boolean', '__httpwww_opengis_netgml3_2_BooleanPropertyType_httpwww_opengis_netgml3_2Boolean', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/valueObjects.xsd', 24, 1), )

    
    Boolean = property(__Boolean.value, __Boolean.set, None, None)

    
    # Attribute {http://www.opengis.net/gml/3.2}remoteSchema uses Python identifier remoteSchema
    __remoteSchema = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gml, 'remoteSchema'), 'remoteSchema', '__httpwww_opengis_netgml3_2_BooleanPropertyType_httpwww_opengis_netgml3_2remoteSchema', pyxb.binding.datatypes.anyURI)
    __remoteSchema._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 638, 1)
    __remoteSchema._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 52, 2)
    
    remoteSchema = property(__remoteSchema.value, __remoteSchema.set, None, '')

    
    # Attribute nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'nilReason'), 'nilReason', '__httpwww_opengis_netgml3_2_BooleanPropertyType_nilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 51, 2)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 51, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}type uses Python identifier type
    __type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'type'), 'type', '__httpwww_opengis_netgml3_2_BooleanPropertyType_httpwww_w3_org1999xlinktype', _ImportedBinding_bindings_v1411_write__xlink.typeType, fixed=True, unicode_default='simple')
    __type._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 29, 1)
    __type._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 112, 2)
    
    type = property(__type.value, __type.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}href uses Python identifier href
    __href = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'href'), 'href', '__httpwww_opengis_netgml3_2_BooleanPropertyType_httpwww_w3_org1999xlinkhref', _ImportedBinding_bindings_v1411_write__xlink.hrefType)
    __href._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 42, 1)
    __href._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 113, 2)
    
    href = property(__href.value, __href.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}role uses Python identifier role
    __role = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'role'), 'role', '__httpwww_opengis_netgml3_2_BooleanPropertyType_httpwww_w3_org1999xlinkrole', _ImportedBinding_bindings_v1411_write__xlink.roleType)
    __role._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 48, 1)
    __role._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 114, 2)
    
    role = property(__role.value, __role.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}arcrole uses Python identifier arcrole
    __arcrole = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'arcrole'), 'arcrole', '__httpwww_opengis_netgml3_2_BooleanPropertyType_httpwww_w3_org1999xlinkarcrole', _ImportedBinding_bindings_v1411_write__xlink.arcroleType)
    __arcrole._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 56, 1)
    __arcrole._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 115, 2)
    
    arcrole = property(__arcrole.value, __arcrole.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}title uses Python identifier title
    __title = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'title'), 'title', '__httpwww_opengis_netgml3_2_BooleanPropertyType_httpwww_w3_org1999xlinktitle', _ImportedBinding_bindings_v1411_write__xlink.titleAttrType)
    __title._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 64, 1)
    __title._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 116, 2)
    
    title = property(__title.value, __title.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}show uses Python identifier show
    __show = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'show'), 'show', '__httpwww_opengis_netgml3_2_BooleanPropertyType_httpwww_w3_org1999xlinkshow', _ImportedBinding_bindings_v1411_write__xlink.showType)
    __show._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 70, 1)
    __show._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 117, 2)
    
    show = property(__show.value, __show.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}actuate uses Python identifier actuate
    __actuate = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'actuate'), 'actuate', '__httpwww_opengis_netgml3_2_BooleanPropertyType_httpwww_w3_org1999xlinkactuate', _ImportedBinding_bindings_v1411_write__xlink.actuateType)
    __actuate._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 82, 1)
    __actuate._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 118, 2)
    
    actuate = property(__actuate.value, __actuate.set, None, None)

    _ElementMap.update({
        __Boolean.name() : __Boolean
    })
    _AttributeMap.update({
        __remoteSchema.name() : __remoteSchema,
        __nilReason.name() : __nilReason,
        __type.name() : __type,
        __href.name() : __href,
        __role.name() : __role,
        __arcrole.name() : __arcrole,
        __title.name() : __title,
        __show.name() : __show,
        __actuate.name() : __actuate
    })
_module_typeBindings.BooleanPropertyType = BooleanPropertyType
_Namespace_gml.addCategoryObject('typeBinding', 'BooleanPropertyType', BooleanPropertyType)


# Complex type {http://www.opengis.net/gml/3.2}CategoryPropertyType with content type ELEMENT_ONLY
class CategoryPropertyType (pyxb.binding.basis.complexTypeDefinition):
    """Complex type {http://www.opengis.net/gml/3.2}CategoryPropertyType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'CategoryPropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/valueObjects.xsd', 187, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.opengis.net/gml/3.2}Category uses Python identifier Category
    __Category = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'Category'), 'Category', '__httpwww_opengis_netgml3_2_CategoryPropertyType_httpwww_opengis_netgml3_2Category', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/valueObjects.xsd', 34, 1), )

    
    Category = property(__Category.value, __Category.set, None, 'A gml:Category has an optional XML attribute codeSpace, whose value is a URI which identifies a dictionary, codelist or authority for the term.')

    
    # Attribute {http://www.opengis.net/gml/3.2}remoteSchema uses Python identifier remoteSchema
    __remoteSchema = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gml, 'remoteSchema'), 'remoteSchema', '__httpwww_opengis_netgml3_2_CategoryPropertyType_httpwww_opengis_netgml3_2remoteSchema', pyxb.binding.datatypes.anyURI)
    __remoteSchema._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 638, 1)
    __remoteSchema._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 52, 2)
    
    remoteSchema = property(__remoteSchema.value, __remoteSchema.set, None, '')

    
    # Attribute nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'nilReason'), 'nilReason', '__httpwww_opengis_netgml3_2_CategoryPropertyType_nilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 51, 2)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 51, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}type uses Python identifier type
    __type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'type'), 'type', '__httpwww_opengis_netgml3_2_CategoryPropertyType_httpwww_w3_org1999xlinktype', _ImportedBinding_bindings_v1411_write__xlink.typeType, fixed=True, unicode_default='simple')
    __type._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 29, 1)
    __type._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 112, 2)
    
    type = property(__type.value, __type.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}href uses Python identifier href
    __href = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'href'), 'href', '__httpwww_opengis_netgml3_2_CategoryPropertyType_httpwww_w3_org1999xlinkhref', _ImportedBinding_bindings_v1411_write__xlink.hrefType)
    __href._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 42, 1)
    __href._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 113, 2)
    
    href = property(__href.value, __href.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}role uses Python identifier role
    __role = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'role'), 'role', '__httpwww_opengis_netgml3_2_CategoryPropertyType_httpwww_w3_org1999xlinkrole', _ImportedBinding_bindings_v1411_write__xlink.roleType)
    __role._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 48, 1)
    __role._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 114, 2)
    
    role = property(__role.value, __role.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}arcrole uses Python identifier arcrole
    __arcrole = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'arcrole'), 'arcrole', '__httpwww_opengis_netgml3_2_CategoryPropertyType_httpwww_w3_org1999xlinkarcrole', _ImportedBinding_bindings_v1411_write__xlink.arcroleType)
    __arcrole._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 56, 1)
    __arcrole._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 115, 2)
    
    arcrole = property(__arcrole.value, __arcrole.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}title uses Python identifier title
    __title = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'title'), 'title', '__httpwww_opengis_netgml3_2_CategoryPropertyType_httpwww_w3_org1999xlinktitle', _ImportedBinding_bindings_v1411_write__xlink.titleAttrType)
    __title._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 64, 1)
    __title._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 116, 2)
    
    title = property(__title.value, __title.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}show uses Python identifier show
    __show = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'show'), 'show', '__httpwww_opengis_netgml3_2_CategoryPropertyType_httpwww_w3_org1999xlinkshow', _ImportedBinding_bindings_v1411_write__xlink.showType)
    __show._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 70, 1)
    __show._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 117, 2)
    
    show = property(__show.value, __show.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}actuate uses Python identifier actuate
    __actuate = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'actuate'), 'actuate', '__httpwww_opengis_netgml3_2_CategoryPropertyType_httpwww_w3_org1999xlinkactuate', _ImportedBinding_bindings_v1411_write__xlink.actuateType)
    __actuate._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 82, 1)
    __actuate._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 118, 2)
    
    actuate = property(__actuate.value, __actuate.set, None, None)

    _ElementMap.update({
        __Category.name() : __Category
    })
    _AttributeMap.update({
        __remoteSchema.name() : __remoteSchema,
        __nilReason.name() : __nilReason,
        __type.name() : __type,
        __href.name() : __href,
        __role.name() : __role,
        __arcrole.name() : __arcrole,
        __title.name() : __title,
        __show.name() : __show,
        __actuate.name() : __actuate
    })
_module_typeBindings.CategoryPropertyType = CategoryPropertyType
_Namespace_gml.addCategoryObject('typeBinding', 'CategoryPropertyType', CategoryPropertyType)


# Complex type {http://www.opengis.net/gml/3.2}QuantityPropertyType with content type ELEMENT_ONLY
class QuantityPropertyType (pyxb.binding.basis.complexTypeDefinition):
    """Complex type {http://www.opengis.net/gml/3.2}QuantityPropertyType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'QuantityPropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/valueObjects.xsd', 193, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.opengis.net/gml/3.2}Quantity uses Python identifier Quantity
    __Quantity = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'Quantity'), 'Quantity', '__httpwww_opengis_netgml3_2_QuantityPropertyType_httpwww_opengis_netgml3_2Quantity', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/valueObjects.xsd', 57, 1), )

    
    Quantity = property(__Quantity.value, __Quantity.set, None, 'An XML attribute uom ("unit of measure") is required, whose value is a URI which identifies the definition of a ratio scale or units by which the numeric value shall be multiplied, or an interval or position scale on which the value occurs.')

    
    # Attribute {http://www.opengis.net/gml/3.2}remoteSchema uses Python identifier remoteSchema
    __remoteSchema = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gml, 'remoteSchema'), 'remoteSchema', '__httpwww_opengis_netgml3_2_QuantityPropertyType_httpwww_opengis_netgml3_2remoteSchema', pyxb.binding.datatypes.anyURI)
    __remoteSchema._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 638, 1)
    __remoteSchema._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 52, 2)
    
    remoteSchema = property(__remoteSchema.value, __remoteSchema.set, None, '')

    
    # Attribute nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'nilReason'), 'nilReason', '__httpwww_opengis_netgml3_2_QuantityPropertyType_nilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 51, 2)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 51, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}type uses Python identifier type
    __type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'type'), 'type', '__httpwww_opengis_netgml3_2_QuantityPropertyType_httpwww_w3_org1999xlinktype', _ImportedBinding_bindings_v1411_write__xlink.typeType, fixed=True, unicode_default='simple')
    __type._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 29, 1)
    __type._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 112, 2)
    
    type = property(__type.value, __type.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}href uses Python identifier href
    __href = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'href'), 'href', '__httpwww_opengis_netgml3_2_QuantityPropertyType_httpwww_w3_org1999xlinkhref', _ImportedBinding_bindings_v1411_write__xlink.hrefType)
    __href._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 42, 1)
    __href._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 113, 2)
    
    href = property(__href.value, __href.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}role uses Python identifier role
    __role = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'role'), 'role', '__httpwww_opengis_netgml3_2_QuantityPropertyType_httpwww_w3_org1999xlinkrole', _ImportedBinding_bindings_v1411_write__xlink.roleType)
    __role._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 48, 1)
    __role._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 114, 2)
    
    role = property(__role.value, __role.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}arcrole uses Python identifier arcrole
    __arcrole = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'arcrole'), 'arcrole', '__httpwww_opengis_netgml3_2_QuantityPropertyType_httpwww_w3_org1999xlinkarcrole', _ImportedBinding_bindings_v1411_write__xlink.arcroleType)
    __arcrole._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 56, 1)
    __arcrole._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 115, 2)
    
    arcrole = property(__arcrole.value, __arcrole.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}title uses Python identifier title
    __title = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'title'), 'title', '__httpwww_opengis_netgml3_2_QuantityPropertyType_httpwww_w3_org1999xlinktitle', _ImportedBinding_bindings_v1411_write__xlink.titleAttrType)
    __title._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 64, 1)
    __title._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 116, 2)
    
    title = property(__title.value, __title.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}show uses Python identifier show
    __show = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'show'), 'show', '__httpwww_opengis_netgml3_2_QuantityPropertyType_httpwww_w3_org1999xlinkshow', _ImportedBinding_bindings_v1411_write__xlink.showType)
    __show._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 70, 1)
    __show._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 117, 2)
    
    show = property(__show.value, __show.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}actuate uses Python identifier actuate
    __actuate = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'actuate'), 'actuate', '__httpwww_opengis_netgml3_2_QuantityPropertyType_httpwww_w3_org1999xlinkactuate', _ImportedBinding_bindings_v1411_write__xlink.actuateType)
    __actuate._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 82, 1)
    __actuate._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 118, 2)
    
    actuate = property(__actuate.value, __actuate.set, None, None)

    _ElementMap.update({
        __Quantity.name() : __Quantity
    })
    _AttributeMap.update({
        __remoteSchema.name() : __remoteSchema,
        __nilReason.name() : __nilReason,
        __type.name() : __type,
        __href.name() : __href,
        __role.name() : __role,
        __arcrole.name() : __arcrole,
        __title.name() : __title,
        __show.name() : __show,
        __actuate.name() : __actuate
    })
_module_typeBindings.QuantityPropertyType = QuantityPropertyType
_Namespace_gml.addCategoryObject('typeBinding', 'QuantityPropertyType', QuantityPropertyType)


# Complex type {http://www.opengis.net/gml/3.2}CountPropertyType with content type ELEMENT_ONLY
class CountPropertyType (pyxb.binding.basis.complexTypeDefinition):
    """Complex type {http://www.opengis.net/gml/3.2}CountPropertyType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'CountPropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/valueObjects.xsd', 199, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.opengis.net/gml/3.2}Count uses Python identifier Count
    __Count = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'Count'), 'Count', '__httpwww_opengis_netgml3_2_CountPropertyType_httpwww_opengis_netgml3_2Count', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/valueObjects.xsd', 47, 1), )

    
    Count = property(__Count.value, __Count.set, None, None)

    
    # Attribute {http://www.opengis.net/gml/3.2}remoteSchema uses Python identifier remoteSchema
    __remoteSchema = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gml, 'remoteSchema'), 'remoteSchema', '__httpwww_opengis_netgml3_2_CountPropertyType_httpwww_opengis_netgml3_2remoteSchema', pyxb.binding.datatypes.anyURI)
    __remoteSchema._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 638, 1)
    __remoteSchema._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 52, 2)
    
    remoteSchema = property(__remoteSchema.value, __remoteSchema.set, None, '')

    
    # Attribute nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'nilReason'), 'nilReason', '__httpwww_opengis_netgml3_2_CountPropertyType_nilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 51, 2)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 51, 2)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}type uses Python identifier type
    __type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'type'), 'type', '__httpwww_opengis_netgml3_2_CountPropertyType_httpwww_w3_org1999xlinktype', _ImportedBinding_bindings_v1411_write__xlink.typeType, fixed=True, unicode_default='simple')
    __type._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 29, 1)
    __type._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 112, 2)
    
    type = property(__type.value, __type.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}href uses Python identifier href
    __href = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'href'), 'href', '__httpwww_opengis_netgml3_2_CountPropertyType_httpwww_w3_org1999xlinkhref', _ImportedBinding_bindings_v1411_write__xlink.hrefType)
    __href._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 42, 1)
    __href._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 113, 2)
    
    href = property(__href.value, __href.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}role uses Python identifier role
    __role = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'role'), 'role', '__httpwww_opengis_netgml3_2_CountPropertyType_httpwww_w3_org1999xlinkrole', _ImportedBinding_bindings_v1411_write__xlink.roleType)
    __role._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 48, 1)
    __role._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 114, 2)
    
    role = property(__role.value, __role.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}arcrole uses Python identifier arcrole
    __arcrole = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'arcrole'), 'arcrole', '__httpwww_opengis_netgml3_2_CountPropertyType_httpwww_w3_org1999xlinkarcrole', _ImportedBinding_bindings_v1411_write__xlink.arcroleType)
    __arcrole._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 56, 1)
    __arcrole._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 115, 2)
    
    arcrole = property(__arcrole.value, __arcrole.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}title uses Python identifier title
    __title = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'title'), 'title', '__httpwww_opengis_netgml3_2_CountPropertyType_httpwww_w3_org1999xlinktitle', _ImportedBinding_bindings_v1411_write__xlink.titleAttrType)
    __title._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 64, 1)
    __title._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 116, 2)
    
    title = property(__title.value, __title.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}show uses Python identifier show
    __show = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'show'), 'show', '__httpwww_opengis_netgml3_2_CountPropertyType_httpwww_w3_org1999xlinkshow', _ImportedBinding_bindings_v1411_write__xlink.showType)
    __show._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 70, 1)
    __show._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 117, 2)
    
    show = property(__show.value, __show.set, None, None)

    
    # Attribute {http://www.w3.org/1999/xlink}actuate uses Python identifier actuate
    __actuate = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_xlink, 'actuate'), 'actuate', '__httpwww_opengis_netgml3_2_CountPropertyType_httpwww_w3_org1999xlinkactuate', _ImportedBinding_bindings_v1411_write__xlink.actuateType)
    __actuate._DeclarationLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 82, 1)
    __actuate._UseLocation = pyxb.utils.utility.Location('http://www.w3.org/1999/xlink.xsd', 118, 2)
    
    actuate = property(__actuate.value, __actuate.set, None, None)

    _ElementMap.update({
        __Count.name() : __Count
    })
    _AttributeMap.update({
        __remoteSchema.name() : __remoteSchema,
        __nilReason.name() : __nilReason,
        __type.name() : __type,
        __href.name() : __href,
        __role.name() : __role,
        __arcrole.name() : __arcrole,
        __title.name() : __title,
        __show.name() : __show,
        __actuate.name() : __actuate
    })
_module_typeBindings.CountPropertyType = CountPropertyType
_Namespace_gml.addCategoryObject('typeBinding', 'CountPropertyType', CountPropertyType)


# Complex type {http://www.isotc211.org/2005/gmd}MD_ImageDescription_Type with content type ELEMENT_ONLY
class MD_ImageDescription_Type (MD_CoverageDescription_Type):
    """Information about an image's suitability for use"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_ImageDescription_Type')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/content.xsd', 67, 1)
    _ElementMap = MD_CoverageDescription_Type._ElementMap.copy()
    _AttributeMap = MD_CoverageDescription_Type._AttributeMap.copy()
    # Base type is MD_CoverageDescription_Type
    
    # Element attributeDescription ({http://www.isotc211.org/2005/gmd}attributeDescription) inherited from {http://www.isotc211.org/2005/gmd}MD_CoverageDescription_Type
    
    # Element contentType ({http://www.isotc211.org/2005/gmd}contentType) inherited from {http://www.isotc211.org/2005/gmd}MD_CoverageDescription_Type
    
    # Element dimension ({http://www.isotc211.org/2005/gmd}dimension) inherited from {http://www.isotc211.org/2005/gmd}MD_CoverageDescription_Type
    
    # Element {http://www.isotc211.org/2005/gmd}illuminationElevationAngle uses Python identifier illuminationElevationAngle
    __illuminationElevationAngle = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'illuminationElevationAngle'), 'illuminationElevationAngle', '__httpwww_isotc211_org2005gmd_MD_ImageDescription_Type_httpwww_isotc211_org2005gmdilluminationElevationAngle', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/content.xsd', 74, 5), )

    
    illuminationElevationAngle = property(__illuminationElevationAngle.value, __illuminationElevationAngle.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}illuminationAzimuthAngle uses Python identifier illuminationAzimuthAngle
    __illuminationAzimuthAngle = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'illuminationAzimuthAngle'), 'illuminationAzimuthAngle', '__httpwww_isotc211_org2005gmd_MD_ImageDescription_Type_httpwww_isotc211_org2005gmdilluminationAzimuthAngle', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/content.xsd', 75, 5), )

    
    illuminationAzimuthAngle = property(__illuminationAzimuthAngle.value, __illuminationAzimuthAngle.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}imagingCondition uses Python identifier imagingCondition
    __imagingCondition = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'imagingCondition'), 'imagingCondition', '__httpwww_isotc211_org2005gmd_MD_ImageDescription_Type_httpwww_isotc211_org2005gmdimagingCondition', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/content.xsd', 76, 5), )

    
    imagingCondition = property(__imagingCondition.value, __imagingCondition.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}imageQualityCode uses Python identifier imageQualityCode
    __imageQualityCode = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'imageQualityCode'), 'imageQualityCode', '__httpwww_isotc211_org2005gmd_MD_ImageDescription_Type_httpwww_isotc211_org2005gmdimageQualityCode', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/content.xsd', 77, 5), )

    
    imageQualityCode = property(__imageQualityCode.value, __imageQualityCode.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}cloudCoverPercentage uses Python identifier cloudCoverPercentage
    __cloudCoverPercentage = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'cloudCoverPercentage'), 'cloudCoverPercentage', '__httpwww_isotc211_org2005gmd_MD_ImageDescription_Type_httpwww_isotc211_org2005gmdcloudCoverPercentage', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/content.xsd', 78, 5), )

    
    cloudCoverPercentage = property(__cloudCoverPercentage.value, __cloudCoverPercentage.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}processingLevelCode uses Python identifier processingLevelCode
    __processingLevelCode = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'processingLevelCode'), 'processingLevelCode', '__httpwww_isotc211_org2005gmd_MD_ImageDescription_Type_httpwww_isotc211_org2005gmdprocessingLevelCode', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/content.xsd', 79, 5), )

    
    processingLevelCode = property(__processingLevelCode.value, __processingLevelCode.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}compressionGenerationQuantity uses Python identifier compressionGenerationQuantity
    __compressionGenerationQuantity = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'compressionGenerationQuantity'), 'compressionGenerationQuantity', '__httpwww_isotc211_org2005gmd_MD_ImageDescription_Type_httpwww_isotc211_org2005gmdcompressionGenerationQuantity', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/content.xsd', 80, 5), )

    
    compressionGenerationQuantity = property(__compressionGenerationQuantity.value, __compressionGenerationQuantity.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}triangulationIndicator uses Python identifier triangulationIndicator
    __triangulationIndicator = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'triangulationIndicator'), 'triangulationIndicator', '__httpwww_isotc211_org2005gmd_MD_ImageDescription_Type_httpwww_isotc211_org2005gmdtriangulationIndicator', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/content.xsd', 81, 5), )

    
    triangulationIndicator = property(__triangulationIndicator.value, __triangulationIndicator.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}radiometricCalibrationDataAvailability uses Python identifier radiometricCalibrationDataAvailability
    __radiometricCalibrationDataAvailability = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'radiometricCalibrationDataAvailability'), 'radiometricCalibrationDataAvailability', '__httpwww_isotc211_org2005gmd_MD_ImageDescription_Type_httpwww_isotc211_org2005gmdradiometricCalibrationDataAvailability', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/content.xsd', 82, 5), )

    
    radiometricCalibrationDataAvailability = property(__radiometricCalibrationDataAvailability.value, __radiometricCalibrationDataAvailability.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}cameraCalibrationInformationAvailability uses Python identifier cameraCalibrationInformationAvailability
    __cameraCalibrationInformationAvailability = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'cameraCalibrationInformationAvailability'), 'cameraCalibrationInformationAvailability', '__httpwww_isotc211_org2005gmd_MD_ImageDescription_Type_httpwww_isotc211_org2005gmdcameraCalibrationInformationAvailability', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/content.xsd', 83, 5), )

    
    cameraCalibrationInformationAvailability = property(__cameraCalibrationInformationAvailability.value, __cameraCalibrationInformationAvailability.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}filmDistortionInformationAvailability uses Python identifier filmDistortionInformationAvailability
    __filmDistortionInformationAvailability = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'filmDistortionInformationAvailability'), 'filmDistortionInformationAvailability', '__httpwww_isotc211_org2005gmd_MD_ImageDescription_Type_httpwww_isotc211_org2005gmdfilmDistortionInformationAvailability', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/content.xsd', 84, 5), )

    
    filmDistortionInformationAvailability = property(__filmDistortionInformationAvailability.value, __filmDistortionInformationAvailability.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}lensDistortionInformationAvailability uses Python identifier lensDistortionInformationAvailability
    __lensDistortionInformationAvailability = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'lensDistortionInformationAvailability'), 'lensDistortionInformationAvailability', '__httpwww_isotc211_org2005gmd_MD_ImageDescription_Type_httpwww_isotc211_org2005gmdlensDistortionInformationAvailability', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/content.xsd', 85, 5), )

    
    lensDistortionInformationAvailability = property(__lensDistortionInformationAvailability.value, __lensDistortionInformationAvailability.set, None, None)

    
    # Attribute id inherited from {http://www.isotc211.org/2005/gco}AbstractObject_Type
    
    # Attribute uuid inherited from {http://www.isotc211.org/2005/gco}AbstractObject_Type
    _ElementMap.update({
        __illuminationElevationAngle.name() : __illuminationElevationAngle,
        __illuminationAzimuthAngle.name() : __illuminationAzimuthAngle,
        __imagingCondition.name() : __imagingCondition,
        __imageQualityCode.name() : __imageQualityCode,
        __cloudCoverPercentage.name() : __cloudCoverPercentage,
        __processingLevelCode.name() : __processingLevelCode,
        __compressionGenerationQuantity.name() : __compressionGenerationQuantity,
        __triangulationIndicator.name() : __triangulationIndicator,
        __radiometricCalibrationDataAvailability.name() : __radiometricCalibrationDataAvailability,
        __cameraCalibrationInformationAvailability.name() : __cameraCalibrationInformationAvailability,
        __filmDistortionInformationAvailability.name() : __filmDistortionInformationAvailability,
        __lensDistortionInformationAvailability.name() : __lensDistortionInformationAvailability
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.MD_ImageDescription_Type = MD_ImageDescription_Type
_Namespace_gmd.addCategoryObject('typeBinding', 'MD_ImageDescription_Type', MD_ImageDescription_Type)


# Complex type {http://www.isotc211.org/2005/gmd}DQ_TemporalValidity_Type with content type ELEMENT_ONLY
class DQ_TemporalValidity_Type (AbstractDQ_TemporalAccuracy_Type):
    """Complex type {http://www.isotc211.org/2005/gmd}DQ_TemporalValidity_Type with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'DQ_TemporalValidity_Type')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 155, 1)
    _ElementMap = AbstractDQ_TemporalAccuracy_Type._ElementMap.copy()
    _AttributeMap = AbstractDQ_TemporalAccuracy_Type._AttributeMap.copy()
    # Base type is AbstractDQ_TemporalAccuracy_Type
    
    # Element nameOfMeasure ({http://www.isotc211.org/2005/gmd}nameOfMeasure) inherited from {http://www.isotc211.org/2005/gmd}AbstractDQ_Element_Type
    
    # Element measureIdentification ({http://www.isotc211.org/2005/gmd}measureIdentification) inherited from {http://www.isotc211.org/2005/gmd}AbstractDQ_Element_Type
    
    # Element measureDescription ({http://www.isotc211.org/2005/gmd}measureDescription) inherited from {http://www.isotc211.org/2005/gmd}AbstractDQ_Element_Type
    
    # Element evaluationMethodType ({http://www.isotc211.org/2005/gmd}evaluationMethodType) inherited from {http://www.isotc211.org/2005/gmd}AbstractDQ_Element_Type
    
    # Element evaluationMethodDescription ({http://www.isotc211.org/2005/gmd}evaluationMethodDescription) inherited from {http://www.isotc211.org/2005/gmd}AbstractDQ_Element_Type
    
    # Element evaluationProcedure ({http://www.isotc211.org/2005/gmd}evaluationProcedure) inherited from {http://www.isotc211.org/2005/gmd}AbstractDQ_Element_Type
    
    # Element dateTime ({http://www.isotc211.org/2005/gmd}dateTime) inherited from {http://www.isotc211.org/2005/gmd}AbstractDQ_Element_Type
    
    # Element result ({http://www.isotc211.org/2005/gmd}result) inherited from {http://www.isotc211.org/2005/gmd}AbstractDQ_Element_Type
    
    # Attribute id inherited from {http://www.isotc211.org/2005/gco}AbstractObject_Type
    
    # Attribute uuid inherited from {http://www.isotc211.org/2005/gco}AbstractObject_Type
    _ElementMap.update({
        
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.DQ_TemporalValidity_Type = DQ_TemporalValidity_Type
_Namespace_gmd.addCategoryObject('typeBinding', 'DQ_TemporalValidity_Type', DQ_TemporalValidity_Type)


# Complex type {http://www.isotc211.org/2005/gmd}DQ_TemporalConsistency_Type with content type ELEMENT_ONLY
class DQ_TemporalConsistency_Type (AbstractDQ_TemporalAccuracy_Type):
    """Complex type {http://www.isotc211.org/2005/gmd}DQ_TemporalConsistency_Type with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'DQ_TemporalConsistency_Type')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 171, 1)
    _ElementMap = AbstractDQ_TemporalAccuracy_Type._ElementMap.copy()
    _AttributeMap = AbstractDQ_TemporalAccuracy_Type._AttributeMap.copy()
    # Base type is AbstractDQ_TemporalAccuracy_Type
    
    # Element nameOfMeasure ({http://www.isotc211.org/2005/gmd}nameOfMeasure) inherited from {http://www.isotc211.org/2005/gmd}AbstractDQ_Element_Type
    
    # Element measureIdentification ({http://www.isotc211.org/2005/gmd}measureIdentification) inherited from {http://www.isotc211.org/2005/gmd}AbstractDQ_Element_Type
    
    # Element measureDescription ({http://www.isotc211.org/2005/gmd}measureDescription) inherited from {http://www.isotc211.org/2005/gmd}AbstractDQ_Element_Type
    
    # Element evaluationMethodType ({http://www.isotc211.org/2005/gmd}evaluationMethodType) inherited from {http://www.isotc211.org/2005/gmd}AbstractDQ_Element_Type
    
    # Element evaluationMethodDescription ({http://www.isotc211.org/2005/gmd}evaluationMethodDescription) inherited from {http://www.isotc211.org/2005/gmd}AbstractDQ_Element_Type
    
    # Element evaluationProcedure ({http://www.isotc211.org/2005/gmd}evaluationProcedure) inherited from {http://www.isotc211.org/2005/gmd}AbstractDQ_Element_Type
    
    # Element dateTime ({http://www.isotc211.org/2005/gmd}dateTime) inherited from {http://www.isotc211.org/2005/gmd}AbstractDQ_Element_Type
    
    # Element result ({http://www.isotc211.org/2005/gmd}result) inherited from {http://www.isotc211.org/2005/gmd}AbstractDQ_Element_Type
    
    # Attribute id inherited from {http://www.isotc211.org/2005/gco}AbstractObject_Type
    
    # Attribute uuid inherited from {http://www.isotc211.org/2005/gco}AbstractObject_Type
    _ElementMap.update({
        
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.DQ_TemporalConsistency_Type = DQ_TemporalConsistency_Type
_Namespace_gmd.addCategoryObject('typeBinding', 'DQ_TemporalConsistency_Type', DQ_TemporalConsistency_Type)


# Complex type {http://www.isotc211.org/2005/gmd}DQ_AccuracyOfATimeMeasurement_Type with content type ELEMENT_ONLY
class DQ_AccuracyOfATimeMeasurement_Type (AbstractDQ_TemporalAccuracy_Type):
    """Complex type {http://www.isotc211.org/2005/gmd}DQ_AccuracyOfATimeMeasurement_Type with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'DQ_AccuracyOfATimeMeasurement_Type')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 187, 1)
    _ElementMap = AbstractDQ_TemporalAccuracy_Type._ElementMap.copy()
    _AttributeMap = AbstractDQ_TemporalAccuracy_Type._AttributeMap.copy()
    # Base type is AbstractDQ_TemporalAccuracy_Type
    
    # Element nameOfMeasure ({http://www.isotc211.org/2005/gmd}nameOfMeasure) inherited from {http://www.isotc211.org/2005/gmd}AbstractDQ_Element_Type
    
    # Element measureIdentification ({http://www.isotc211.org/2005/gmd}measureIdentification) inherited from {http://www.isotc211.org/2005/gmd}AbstractDQ_Element_Type
    
    # Element measureDescription ({http://www.isotc211.org/2005/gmd}measureDescription) inherited from {http://www.isotc211.org/2005/gmd}AbstractDQ_Element_Type
    
    # Element evaluationMethodType ({http://www.isotc211.org/2005/gmd}evaluationMethodType) inherited from {http://www.isotc211.org/2005/gmd}AbstractDQ_Element_Type
    
    # Element evaluationMethodDescription ({http://www.isotc211.org/2005/gmd}evaluationMethodDescription) inherited from {http://www.isotc211.org/2005/gmd}AbstractDQ_Element_Type
    
    # Element evaluationProcedure ({http://www.isotc211.org/2005/gmd}evaluationProcedure) inherited from {http://www.isotc211.org/2005/gmd}AbstractDQ_Element_Type
    
    # Element dateTime ({http://www.isotc211.org/2005/gmd}dateTime) inherited from {http://www.isotc211.org/2005/gmd}AbstractDQ_Element_Type
    
    # Element result ({http://www.isotc211.org/2005/gmd}result) inherited from {http://www.isotc211.org/2005/gmd}AbstractDQ_Element_Type
    
    # Attribute id inherited from {http://www.isotc211.org/2005/gco}AbstractObject_Type
    
    # Attribute uuid inherited from {http://www.isotc211.org/2005/gco}AbstractObject_Type
    _ElementMap.update({
        
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.DQ_AccuracyOfATimeMeasurement_Type = DQ_AccuracyOfATimeMeasurement_Type
_Namespace_gmd.addCategoryObject('typeBinding', 'DQ_AccuracyOfATimeMeasurement_Type', DQ_AccuracyOfATimeMeasurement_Type)


# Complex type {http://www.isotc211.org/2005/gmd}DQ_QuantitativeAttributeAccuracy_Type with content type ELEMENT_ONLY
class DQ_QuantitativeAttributeAccuracy_Type (AbstractDQ_ThematicAccuracy_Type):
    """Complex type {http://www.isotc211.org/2005/gmd}DQ_QuantitativeAttributeAccuracy_Type with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'DQ_QuantitativeAttributeAccuracy_Type')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 203, 1)
    _ElementMap = AbstractDQ_ThematicAccuracy_Type._ElementMap.copy()
    _AttributeMap = AbstractDQ_ThematicAccuracy_Type._AttributeMap.copy()
    # Base type is AbstractDQ_ThematicAccuracy_Type
    
    # Element nameOfMeasure ({http://www.isotc211.org/2005/gmd}nameOfMeasure) inherited from {http://www.isotc211.org/2005/gmd}AbstractDQ_Element_Type
    
    # Element measureIdentification ({http://www.isotc211.org/2005/gmd}measureIdentification) inherited from {http://www.isotc211.org/2005/gmd}AbstractDQ_Element_Type
    
    # Element measureDescription ({http://www.isotc211.org/2005/gmd}measureDescription) inherited from {http://www.isotc211.org/2005/gmd}AbstractDQ_Element_Type
    
    # Element evaluationMethodType ({http://www.isotc211.org/2005/gmd}evaluationMethodType) inherited from {http://www.isotc211.org/2005/gmd}AbstractDQ_Element_Type
    
    # Element evaluationMethodDescription ({http://www.isotc211.org/2005/gmd}evaluationMethodDescription) inherited from {http://www.isotc211.org/2005/gmd}AbstractDQ_Element_Type
    
    # Element evaluationProcedure ({http://www.isotc211.org/2005/gmd}evaluationProcedure) inherited from {http://www.isotc211.org/2005/gmd}AbstractDQ_Element_Type
    
    # Element dateTime ({http://www.isotc211.org/2005/gmd}dateTime) inherited from {http://www.isotc211.org/2005/gmd}AbstractDQ_Element_Type
    
    # Element result ({http://www.isotc211.org/2005/gmd}result) inherited from {http://www.isotc211.org/2005/gmd}AbstractDQ_Element_Type
    
    # Attribute id inherited from {http://www.isotc211.org/2005/gco}AbstractObject_Type
    
    # Attribute uuid inherited from {http://www.isotc211.org/2005/gco}AbstractObject_Type
    _ElementMap.update({
        
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.DQ_QuantitativeAttributeAccuracy_Type = DQ_QuantitativeAttributeAccuracy_Type
_Namespace_gmd.addCategoryObject('typeBinding', 'DQ_QuantitativeAttributeAccuracy_Type', DQ_QuantitativeAttributeAccuracy_Type)


# Complex type {http://www.isotc211.org/2005/gmd}DQ_NonQuantitativeAttributeAccuracy_Type with content type ELEMENT_ONLY
class DQ_NonQuantitativeAttributeAccuracy_Type (AbstractDQ_ThematicAccuracy_Type):
    """Complex type {http://www.isotc211.org/2005/gmd}DQ_NonQuantitativeAttributeAccuracy_Type with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'DQ_NonQuantitativeAttributeAccuracy_Type')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 219, 1)
    _ElementMap = AbstractDQ_ThematicAccuracy_Type._ElementMap.copy()
    _AttributeMap = AbstractDQ_ThematicAccuracy_Type._AttributeMap.copy()
    # Base type is AbstractDQ_ThematicAccuracy_Type
    
    # Element nameOfMeasure ({http://www.isotc211.org/2005/gmd}nameOfMeasure) inherited from {http://www.isotc211.org/2005/gmd}AbstractDQ_Element_Type
    
    # Element measureIdentification ({http://www.isotc211.org/2005/gmd}measureIdentification) inherited from {http://www.isotc211.org/2005/gmd}AbstractDQ_Element_Type
    
    # Element measureDescription ({http://www.isotc211.org/2005/gmd}measureDescription) inherited from {http://www.isotc211.org/2005/gmd}AbstractDQ_Element_Type
    
    # Element evaluationMethodType ({http://www.isotc211.org/2005/gmd}evaluationMethodType) inherited from {http://www.isotc211.org/2005/gmd}AbstractDQ_Element_Type
    
    # Element evaluationMethodDescription ({http://www.isotc211.org/2005/gmd}evaluationMethodDescription) inherited from {http://www.isotc211.org/2005/gmd}AbstractDQ_Element_Type
    
    # Element evaluationProcedure ({http://www.isotc211.org/2005/gmd}evaluationProcedure) inherited from {http://www.isotc211.org/2005/gmd}AbstractDQ_Element_Type
    
    # Element dateTime ({http://www.isotc211.org/2005/gmd}dateTime) inherited from {http://www.isotc211.org/2005/gmd}AbstractDQ_Element_Type
    
    # Element result ({http://www.isotc211.org/2005/gmd}result) inherited from {http://www.isotc211.org/2005/gmd}AbstractDQ_Element_Type
    
    # Attribute id inherited from {http://www.isotc211.org/2005/gco}AbstractObject_Type
    
    # Attribute uuid inherited from {http://www.isotc211.org/2005/gco}AbstractObject_Type
    _ElementMap.update({
        
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.DQ_NonQuantitativeAttributeAccuracy_Type = DQ_NonQuantitativeAttributeAccuracy_Type
_Namespace_gmd.addCategoryObject('typeBinding', 'DQ_NonQuantitativeAttributeAccuracy_Type', DQ_NonQuantitativeAttributeAccuracy_Type)


# Complex type {http://www.isotc211.org/2005/gmd}DQ_ThematicClassificationCorrectness_Type with content type ELEMENT_ONLY
class DQ_ThematicClassificationCorrectness_Type (AbstractDQ_ThematicAccuracy_Type):
    """Complex type {http://www.isotc211.org/2005/gmd}DQ_ThematicClassificationCorrectness_Type with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'DQ_ThematicClassificationCorrectness_Type')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 235, 1)
    _ElementMap = AbstractDQ_ThematicAccuracy_Type._ElementMap.copy()
    _AttributeMap = AbstractDQ_ThematicAccuracy_Type._AttributeMap.copy()
    # Base type is AbstractDQ_ThematicAccuracy_Type
    
    # Element nameOfMeasure ({http://www.isotc211.org/2005/gmd}nameOfMeasure) inherited from {http://www.isotc211.org/2005/gmd}AbstractDQ_Element_Type
    
    # Element measureIdentification ({http://www.isotc211.org/2005/gmd}measureIdentification) inherited from {http://www.isotc211.org/2005/gmd}AbstractDQ_Element_Type
    
    # Element measureDescription ({http://www.isotc211.org/2005/gmd}measureDescription) inherited from {http://www.isotc211.org/2005/gmd}AbstractDQ_Element_Type
    
    # Element evaluationMethodType ({http://www.isotc211.org/2005/gmd}evaluationMethodType) inherited from {http://www.isotc211.org/2005/gmd}AbstractDQ_Element_Type
    
    # Element evaluationMethodDescription ({http://www.isotc211.org/2005/gmd}evaluationMethodDescription) inherited from {http://www.isotc211.org/2005/gmd}AbstractDQ_Element_Type
    
    # Element evaluationProcedure ({http://www.isotc211.org/2005/gmd}evaluationProcedure) inherited from {http://www.isotc211.org/2005/gmd}AbstractDQ_Element_Type
    
    # Element dateTime ({http://www.isotc211.org/2005/gmd}dateTime) inherited from {http://www.isotc211.org/2005/gmd}AbstractDQ_Element_Type
    
    # Element result ({http://www.isotc211.org/2005/gmd}result) inherited from {http://www.isotc211.org/2005/gmd}AbstractDQ_Element_Type
    
    # Attribute id inherited from {http://www.isotc211.org/2005/gco}AbstractObject_Type
    
    # Attribute uuid inherited from {http://www.isotc211.org/2005/gco}AbstractObject_Type
    _ElementMap.update({
        
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.DQ_ThematicClassificationCorrectness_Type = DQ_ThematicClassificationCorrectness_Type
_Namespace_gmd.addCategoryObject('typeBinding', 'DQ_ThematicClassificationCorrectness_Type', DQ_ThematicClassificationCorrectness_Type)


# Complex type {http://www.isotc211.org/2005/gmd}DQ_RelativeInternalPositionalAccuracy_Type with content type ELEMENT_ONLY
class DQ_RelativeInternalPositionalAccuracy_Type (AbstractDQ_PositionalAccuracy_Type):
    """Complex type {http://www.isotc211.org/2005/gmd}DQ_RelativeInternalPositionalAccuracy_Type with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'DQ_RelativeInternalPositionalAccuracy_Type')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 251, 1)
    _ElementMap = AbstractDQ_PositionalAccuracy_Type._ElementMap.copy()
    _AttributeMap = AbstractDQ_PositionalAccuracy_Type._AttributeMap.copy()
    # Base type is AbstractDQ_PositionalAccuracy_Type
    
    # Element nameOfMeasure ({http://www.isotc211.org/2005/gmd}nameOfMeasure) inherited from {http://www.isotc211.org/2005/gmd}AbstractDQ_Element_Type
    
    # Element measureIdentification ({http://www.isotc211.org/2005/gmd}measureIdentification) inherited from {http://www.isotc211.org/2005/gmd}AbstractDQ_Element_Type
    
    # Element measureDescription ({http://www.isotc211.org/2005/gmd}measureDescription) inherited from {http://www.isotc211.org/2005/gmd}AbstractDQ_Element_Type
    
    # Element evaluationMethodType ({http://www.isotc211.org/2005/gmd}evaluationMethodType) inherited from {http://www.isotc211.org/2005/gmd}AbstractDQ_Element_Type
    
    # Element evaluationMethodDescription ({http://www.isotc211.org/2005/gmd}evaluationMethodDescription) inherited from {http://www.isotc211.org/2005/gmd}AbstractDQ_Element_Type
    
    # Element evaluationProcedure ({http://www.isotc211.org/2005/gmd}evaluationProcedure) inherited from {http://www.isotc211.org/2005/gmd}AbstractDQ_Element_Type
    
    # Element dateTime ({http://www.isotc211.org/2005/gmd}dateTime) inherited from {http://www.isotc211.org/2005/gmd}AbstractDQ_Element_Type
    
    # Element result ({http://www.isotc211.org/2005/gmd}result) inherited from {http://www.isotc211.org/2005/gmd}AbstractDQ_Element_Type
    
    # Attribute id inherited from {http://www.isotc211.org/2005/gco}AbstractObject_Type
    
    # Attribute uuid inherited from {http://www.isotc211.org/2005/gco}AbstractObject_Type
    _ElementMap.update({
        
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.DQ_RelativeInternalPositionalAccuracy_Type = DQ_RelativeInternalPositionalAccuracy_Type
_Namespace_gmd.addCategoryObject('typeBinding', 'DQ_RelativeInternalPositionalAccuracy_Type', DQ_RelativeInternalPositionalAccuracy_Type)


# Complex type {http://www.isotc211.org/2005/gmd}DQ_GriddedDataPositionalAccuracy_Type with content type ELEMENT_ONLY
class DQ_GriddedDataPositionalAccuracy_Type (AbstractDQ_PositionalAccuracy_Type):
    """Complex type {http://www.isotc211.org/2005/gmd}DQ_GriddedDataPositionalAccuracy_Type with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'DQ_GriddedDataPositionalAccuracy_Type')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 267, 1)
    _ElementMap = AbstractDQ_PositionalAccuracy_Type._ElementMap.copy()
    _AttributeMap = AbstractDQ_PositionalAccuracy_Type._AttributeMap.copy()
    # Base type is AbstractDQ_PositionalAccuracy_Type
    
    # Element nameOfMeasure ({http://www.isotc211.org/2005/gmd}nameOfMeasure) inherited from {http://www.isotc211.org/2005/gmd}AbstractDQ_Element_Type
    
    # Element measureIdentification ({http://www.isotc211.org/2005/gmd}measureIdentification) inherited from {http://www.isotc211.org/2005/gmd}AbstractDQ_Element_Type
    
    # Element measureDescription ({http://www.isotc211.org/2005/gmd}measureDescription) inherited from {http://www.isotc211.org/2005/gmd}AbstractDQ_Element_Type
    
    # Element evaluationMethodType ({http://www.isotc211.org/2005/gmd}evaluationMethodType) inherited from {http://www.isotc211.org/2005/gmd}AbstractDQ_Element_Type
    
    # Element evaluationMethodDescription ({http://www.isotc211.org/2005/gmd}evaluationMethodDescription) inherited from {http://www.isotc211.org/2005/gmd}AbstractDQ_Element_Type
    
    # Element evaluationProcedure ({http://www.isotc211.org/2005/gmd}evaluationProcedure) inherited from {http://www.isotc211.org/2005/gmd}AbstractDQ_Element_Type
    
    # Element dateTime ({http://www.isotc211.org/2005/gmd}dateTime) inherited from {http://www.isotc211.org/2005/gmd}AbstractDQ_Element_Type
    
    # Element result ({http://www.isotc211.org/2005/gmd}result) inherited from {http://www.isotc211.org/2005/gmd}AbstractDQ_Element_Type
    
    # Attribute id inherited from {http://www.isotc211.org/2005/gco}AbstractObject_Type
    
    # Attribute uuid inherited from {http://www.isotc211.org/2005/gco}AbstractObject_Type
    _ElementMap.update({
        
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.DQ_GriddedDataPositionalAccuracy_Type = DQ_GriddedDataPositionalAccuracy_Type
_Namespace_gmd.addCategoryObject('typeBinding', 'DQ_GriddedDataPositionalAccuracy_Type', DQ_GriddedDataPositionalAccuracy_Type)


# Complex type {http://www.isotc211.org/2005/gmd}DQ_AbsoluteExternalPositionalAccuracy_Type with content type ELEMENT_ONLY
class DQ_AbsoluteExternalPositionalAccuracy_Type (AbstractDQ_PositionalAccuracy_Type):
    """Complex type {http://www.isotc211.org/2005/gmd}DQ_AbsoluteExternalPositionalAccuracy_Type with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'DQ_AbsoluteExternalPositionalAccuracy_Type')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 283, 1)
    _ElementMap = AbstractDQ_PositionalAccuracy_Type._ElementMap.copy()
    _AttributeMap = AbstractDQ_PositionalAccuracy_Type._AttributeMap.copy()
    # Base type is AbstractDQ_PositionalAccuracy_Type
    
    # Element nameOfMeasure ({http://www.isotc211.org/2005/gmd}nameOfMeasure) inherited from {http://www.isotc211.org/2005/gmd}AbstractDQ_Element_Type
    
    # Element measureIdentification ({http://www.isotc211.org/2005/gmd}measureIdentification) inherited from {http://www.isotc211.org/2005/gmd}AbstractDQ_Element_Type
    
    # Element measureDescription ({http://www.isotc211.org/2005/gmd}measureDescription) inherited from {http://www.isotc211.org/2005/gmd}AbstractDQ_Element_Type
    
    # Element evaluationMethodType ({http://www.isotc211.org/2005/gmd}evaluationMethodType) inherited from {http://www.isotc211.org/2005/gmd}AbstractDQ_Element_Type
    
    # Element evaluationMethodDescription ({http://www.isotc211.org/2005/gmd}evaluationMethodDescription) inherited from {http://www.isotc211.org/2005/gmd}AbstractDQ_Element_Type
    
    # Element evaluationProcedure ({http://www.isotc211.org/2005/gmd}evaluationProcedure) inherited from {http://www.isotc211.org/2005/gmd}AbstractDQ_Element_Type
    
    # Element dateTime ({http://www.isotc211.org/2005/gmd}dateTime) inherited from {http://www.isotc211.org/2005/gmd}AbstractDQ_Element_Type
    
    # Element result ({http://www.isotc211.org/2005/gmd}result) inherited from {http://www.isotc211.org/2005/gmd}AbstractDQ_Element_Type
    
    # Attribute id inherited from {http://www.isotc211.org/2005/gco}AbstractObject_Type
    
    # Attribute uuid inherited from {http://www.isotc211.org/2005/gco}AbstractObject_Type
    _ElementMap.update({
        
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.DQ_AbsoluteExternalPositionalAccuracy_Type = DQ_AbsoluteExternalPositionalAccuracy_Type
_Namespace_gmd.addCategoryObject('typeBinding', 'DQ_AbsoluteExternalPositionalAccuracy_Type', DQ_AbsoluteExternalPositionalAccuracy_Type)


# Complex type {http://www.isotc211.org/2005/gmd}DQ_TopologicalConsistency_Type with content type ELEMENT_ONLY
class DQ_TopologicalConsistency_Type (AbstractDQ_LogicalConsistency_Type):
    """Complex type {http://www.isotc211.org/2005/gmd}DQ_TopologicalConsistency_Type with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'DQ_TopologicalConsistency_Type')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 299, 1)
    _ElementMap = AbstractDQ_LogicalConsistency_Type._ElementMap.copy()
    _AttributeMap = AbstractDQ_LogicalConsistency_Type._AttributeMap.copy()
    # Base type is AbstractDQ_LogicalConsistency_Type
    
    # Element nameOfMeasure ({http://www.isotc211.org/2005/gmd}nameOfMeasure) inherited from {http://www.isotc211.org/2005/gmd}AbstractDQ_Element_Type
    
    # Element measureIdentification ({http://www.isotc211.org/2005/gmd}measureIdentification) inherited from {http://www.isotc211.org/2005/gmd}AbstractDQ_Element_Type
    
    # Element measureDescription ({http://www.isotc211.org/2005/gmd}measureDescription) inherited from {http://www.isotc211.org/2005/gmd}AbstractDQ_Element_Type
    
    # Element evaluationMethodType ({http://www.isotc211.org/2005/gmd}evaluationMethodType) inherited from {http://www.isotc211.org/2005/gmd}AbstractDQ_Element_Type
    
    # Element evaluationMethodDescription ({http://www.isotc211.org/2005/gmd}evaluationMethodDescription) inherited from {http://www.isotc211.org/2005/gmd}AbstractDQ_Element_Type
    
    # Element evaluationProcedure ({http://www.isotc211.org/2005/gmd}evaluationProcedure) inherited from {http://www.isotc211.org/2005/gmd}AbstractDQ_Element_Type
    
    # Element dateTime ({http://www.isotc211.org/2005/gmd}dateTime) inherited from {http://www.isotc211.org/2005/gmd}AbstractDQ_Element_Type
    
    # Element result ({http://www.isotc211.org/2005/gmd}result) inherited from {http://www.isotc211.org/2005/gmd}AbstractDQ_Element_Type
    
    # Attribute id inherited from {http://www.isotc211.org/2005/gco}AbstractObject_Type
    
    # Attribute uuid inherited from {http://www.isotc211.org/2005/gco}AbstractObject_Type
    _ElementMap.update({
        
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.DQ_TopologicalConsistency_Type = DQ_TopologicalConsistency_Type
_Namespace_gmd.addCategoryObject('typeBinding', 'DQ_TopologicalConsistency_Type', DQ_TopologicalConsistency_Type)


# Complex type {http://www.isotc211.org/2005/gmd}DQ_FormatConsistency_Type with content type ELEMENT_ONLY
class DQ_FormatConsistency_Type (AbstractDQ_LogicalConsistency_Type):
    """Complex type {http://www.isotc211.org/2005/gmd}DQ_FormatConsistency_Type with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'DQ_FormatConsistency_Type')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 315, 1)
    _ElementMap = AbstractDQ_LogicalConsistency_Type._ElementMap.copy()
    _AttributeMap = AbstractDQ_LogicalConsistency_Type._AttributeMap.copy()
    # Base type is AbstractDQ_LogicalConsistency_Type
    
    # Element nameOfMeasure ({http://www.isotc211.org/2005/gmd}nameOfMeasure) inherited from {http://www.isotc211.org/2005/gmd}AbstractDQ_Element_Type
    
    # Element measureIdentification ({http://www.isotc211.org/2005/gmd}measureIdentification) inherited from {http://www.isotc211.org/2005/gmd}AbstractDQ_Element_Type
    
    # Element measureDescription ({http://www.isotc211.org/2005/gmd}measureDescription) inherited from {http://www.isotc211.org/2005/gmd}AbstractDQ_Element_Type
    
    # Element evaluationMethodType ({http://www.isotc211.org/2005/gmd}evaluationMethodType) inherited from {http://www.isotc211.org/2005/gmd}AbstractDQ_Element_Type
    
    # Element evaluationMethodDescription ({http://www.isotc211.org/2005/gmd}evaluationMethodDescription) inherited from {http://www.isotc211.org/2005/gmd}AbstractDQ_Element_Type
    
    # Element evaluationProcedure ({http://www.isotc211.org/2005/gmd}evaluationProcedure) inherited from {http://www.isotc211.org/2005/gmd}AbstractDQ_Element_Type
    
    # Element dateTime ({http://www.isotc211.org/2005/gmd}dateTime) inherited from {http://www.isotc211.org/2005/gmd}AbstractDQ_Element_Type
    
    # Element result ({http://www.isotc211.org/2005/gmd}result) inherited from {http://www.isotc211.org/2005/gmd}AbstractDQ_Element_Type
    
    # Attribute id inherited from {http://www.isotc211.org/2005/gco}AbstractObject_Type
    
    # Attribute uuid inherited from {http://www.isotc211.org/2005/gco}AbstractObject_Type
    _ElementMap.update({
        
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.DQ_FormatConsistency_Type = DQ_FormatConsistency_Type
_Namespace_gmd.addCategoryObject('typeBinding', 'DQ_FormatConsistency_Type', DQ_FormatConsistency_Type)


# Complex type {http://www.isotc211.org/2005/gmd}DQ_DomainConsistency_Type with content type ELEMENT_ONLY
class DQ_DomainConsistency_Type (AbstractDQ_LogicalConsistency_Type):
    """Complex type {http://www.isotc211.org/2005/gmd}DQ_DomainConsistency_Type with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'DQ_DomainConsistency_Type')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 331, 1)
    _ElementMap = AbstractDQ_LogicalConsistency_Type._ElementMap.copy()
    _AttributeMap = AbstractDQ_LogicalConsistency_Type._AttributeMap.copy()
    # Base type is AbstractDQ_LogicalConsistency_Type
    
    # Element nameOfMeasure ({http://www.isotc211.org/2005/gmd}nameOfMeasure) inherited from {http://www.isotc211.org/2005/gmd}AbstractDQ_Element_Type
    
    # Element measureIdentification ({http://www.isotc211.org/2005/gmd}measureIdentification) inherited from {http://www.isotc211.org/2005/gmd}AbstractDQ_Element_Type
    
    # Element measureDescription ({http://www.isotc211.org/2005/gmd}measureDescription) inherited from {http://www.isotc211.org/2005/gmd}AbstractDQ_Element_Type
    
    # Element evaluationMethodType ({http://www.isotc211.org/2005/gmd}evaluationMethodType) inherited from {http://www.isotc211.org/2005/gmd}AbstractDQ_Element_Type
    
    # Element evaluationMethodDescription ({http://www.isotc211.org/2005/gmd}evaluationMethodDescription) inherited from {http://www.isotc211.org/2005/gmd}AbstractDQ_Element_Type
    
    # Element evaluationProcedure ({http://www.isotc211.org/2005/gmd}evaluationProcedure) inherited from {http://www.isotc211.org/2005/gmd}AbstractDQ_Element_Type
    
    # Element dateTime ({http://www.isotc211.org/2005/gmd}dateTime) inherited from {http://www.isotc211.org/2005/gmd}AbstractDQ_Element_Type
    
    # Element result ({http://www.isotc211.org/2005/gmd}result) inherited from {http://www.isotc211.org/2005/gmd}AbstractDQ_Element_Type
    
    # Attribute id inherited from {http://www.isotc211.org/2005/gco}AbstractObject_Type
    
    # Attribute uuid inherited from {http://www.isotc211.org/2005/gco}AbstractObject_Type
    _ElementMap.update({
        
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.DQ_DomainConsistency_Type = DQ_DomainConsistency_Type
_Namespace_gmd.addCategoryObject('typeBinding', 'DQ_DomainConsistency_Type', DQ_DomainConsistency_Type)


# Complex type {http://www.isotc211.org/2005/gmd}DQ_ConceptualConsistency_Type with content type ELEMENT_ONLY
class DQ_ConceptualConsistency_Type (AbstractDQ_LogicalConsistency_Type):
    """Complex type {http://www.isotc211.org/2005/gmd}DQ_ConceptualConsistency_Type with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'DQ_ConceptualConsistency_Type')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 347, 1)
    _ElementMap = AbstractDQ_LogicalConsistency_Type._ElementMap.copy()
    _AttributeMap = AbstractDQ_LogicalConsistency_Type._AttributeMap.copy()
    # Base type is AbstractDQ_LogicalConsistency_Type
    
    # Element nameOfMeasure ({http://www.isotc211.org/2005/gmd}nameOfMeasure) inherited from {http://www.isotc211.org/2005/gmd}AbstractDQ_Element_Type
    
    # Element measureIdentification ({http://www.isotc211.org/2005/gmd}measureIdentification) inherited from {http://www.isotc211.org/2005/gmd}AbstractDQ_Element_Type
    
    # Element measureDescription ({http://www.isotc211.org/2005/gmd}measureDescription) inherited from {http://www.isotc211.org/2005/gmd}AbstractDQ_Element_Type
    
    # Element evaluationMethodType ({http://www.isotc211.org/2005/gmd}evaluationMethodType) inherited from {http://www.isotc211.org/2005/gmd}AbstractDQ_Element_Type
    
    # Element evaluationMethodDescription ({http://www.isotc211.org/2005/gmd}evaluationMethodDescription) inherited from {http://www.isotc211.org/2005/gmd}AbstractDQ_Element_Type
    
    # Element evaluationProcedure ({http://www.isotc211.org/2005/gmd}evaluationProcedure) inherited from {http://www.isotc211.org/2005/gmd}AbstractDQ_Element_Type
    
    # Element dateTime ({http://www.isotc211.org/2005/gmd}dateTime) inherited from {http://www.isotc211.org/2005/gmd}AbstractDQ_Element_Type
    
    # Element result ({http://www.isotc211.org/2005/gmd}result) inherited from {http://www.isotc211.org/2005/gmd}AbstractDQ_Element_Type
    
    # Attribute id inherited from {http://www.isotc211.org/2005/gco}AbstractObject_Type
    
    # Attribute uuid inherited from {http://www.isotc211.org/2005/gco}AbstractObject_Type
    _ElementMap.update({
        
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.DQ_ConceptualConsistency_Type = DQ_ConceptualConsistency_Type
_Namespace_gmd.addCategoryObject('typeBinding', 'DQ_ConceptualConsistency_Type', DQ_ConceptualConsistency_Type)


# Complex type {http://www.isotc211.org/2005/gmd}DQ_CompletenessOmission_Type with content type ELEMENT_ONLY
class DQ_CompletenessOmission_Type (AbstractDQ_Completeness_Type):
    """Complex type {http://www.isotc211.org/2005/gmd}DQ_CompletenessOmission_Type with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'DQ_CompletenessOmission_Type')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 363, 1)
    _ElementMap = AbstractDQ_Completeness_Type._ElementMap.copy()
    _AttributeMap = AbstractDQ_Completeness_Type._AttributeMap.copy()
    # Base type is AbstractDQ_Completeness_Type
    
    # Element nameOfMeasure ({http://www.isotc211.org/2005/gmd}nameOfMeasure) inherited from {http://www.isotc211.org/2005/gmd}AbstractDQ_Element_Type
    
    # Element measureIdentification ({http://www.isotc211.org/2005/gmd}measureIdentification) inherited from {http://www.isotc211.org/2005/gmd}AbstractDQ_Element_Type
    
    # Element measureDescription ({http://www.isotc211.org/2005/gmd}measureDescription) inherited from {http://www.isotc211.org/2005/gmd}AbstractDQ_Element_Type
    
    # Element evaluationMethodType ({http://www.isotc211.org/2005/gmd}evaluationMethodType) inherited from {http://www.isotc211.org/2005/gmd}AbstractDQ_Element_Type
    
    # Element evaluationMethodDescription ({http://www.isotc211.org/2005/gmd}evaluationMethodDescription) inherited from {http://www.isotc211.org/2005/gmd}AbstractDQ_Element_Type
    
    # Element evaluationProcedure ({http://www.isotc211.org/2005/gmd}evaluationProcedure) inherited from {http://www.isotc211.org/2005/gmd}AbstractDQ_Element_Type
    
    # Element dateTime ({http://www.isotc211.org/2005/gmd}dateTime) inherited from {http://www.isotc211.org/2005/gmd}AbstractDQ_Element_Type
    
    # Element result ({http://www.isotc211.org/2005/gmd}result) inherited from {http://www.isotc211.org/2005/gmd}AbstractDQ_Element_Type
    
    # Attribute id inherited from {http://www.isotc211.org/2005/gco}AbstractObject_Type
    
    # Attribute uuid inherited from {http://www.isotc211.org/2005/gco}AbstractObject_Type
    _ElementMap.update({
        
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.DQ_CompletenessOmission_Type = DQ_CompletenessOmission_Type
_Namespace_gmd.addCategoryObject('typeBinding', 'DQ_CompletenessOmission_Type', DQ_CompletenessOmission_Type)


# Complex type {http://www.isotc211.org/2005/gmd}DQ_CompletenessCommission_Type with content type ELEMENT_ONLY
class DQ_CompletenessCommission_Type (AbstractDQ_Completeness_Type):
    """Complex type {http://www.isotc211.org/2005/gmd}DQ_CompletenessCommission_Type with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'DQ_CompletenessCommission_Type')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 379, 1)
    _ElementMap = AbstractDQ_Completeness_Type._ElementMap.copy()
    _AttributeMap = AbstractDQ_Completeness_Type._AttributeMap.copy()
    # Base type is AbstractDQ_Completeness_Type
    
    # Element nameOfMeasure ({http://www.isotc211.org/2005/gmd}nameOfMeasure) inherited from {http://www.isotc211.org/2005/gmd}AbstractDQ_Element_Type
    
    # Element measureIdentification ({http://www.isotc211.org/2005/gmd}measureIdentification) inherited from {http://www.isotc211.org/2005/gmd}AbstractDQ_Element_Type
    
    # Element measureDescription ({http://www.isotc211.org/2005/gmd}measureDescription) inherited from {http://www.isotc211.org/2005/gmd}AbstractDQ_Element_Type
    
    # Element evaluationMethodType ({http://www.isotc211.org/2005/gmd}evaluationMethodType) inherited from {http://www.isotc211.org/2005/gmd}AbstractDQ_Element_Type
    
    # Element evaluationMethodDescription ({http://www.isotc211.org/2005/gmd}evaluationMethodDescription) inherited from {http://www.isotc211.org/2005/gmd}AbstractDQ_Element_Type
    
    # Element evaluationProcedure ({http://www.isotc211.org/2005/gmd}evaluationProcedure) inherited from {http://www.isotc211.org/2005/gmd}AbstractDQ_Element_Type
    
    # Element dateTime ({http://www.isotc211.org/2005/gmd}dateTime) inherited from {http://www.isotc211.org/2005/gmd}AbstractDQ_Element_Type
    
    # Element result ({http://www.isotc211.org/2005/gmd}result) inherited from {http://www.isotc211.org/2005/gmd}AbstractDQ_Element_Type
    
    # Attribute id inherited from {http://www.isotc211.org/2005/gco}AbstractObject_Type
    
    # Attribute uuid inherited from {http://www.isotc211.org/2005/gco}AbstractObject_Type
    _ElementMap.update({
        
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.DQ_CompletenessCommission_Type = DQ_CompletenessCommission_Type
_Namespace_gmd.addCategoryObject('typeBinding', 'DQ_CompletenessCommission_Type', DQ_CompletenessCommission_Type)


# Complex type {http://www.isotc211.org/2005/gmd}PT_FreeText_PropertyType with content type ELEMENT_ONLY
class PT_FreeText_PropertyType (CharacterString_PropertyType):
    """Complex type {http://www.isotc211.org/2005/gmd}PT_FreeText_PropertyType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'PT_FreeText_PropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/freeText.xsd', 26, 1)
    _ElementMap = CharacterString_PropertyType._ElementMap.copy()
    _AttributeMap = CharacterString_PropertyType._AttributeMap.copy()
    # Base type is CharacterString_PropertyType
    
    # Element CharacterString ({http://www.isotc211.org/2005/gco}CharacterString) inherited from {http://www.isotc211.org/2005/gco}CharacterString_PropertyType
    
    # Element {http://www.isotc211.org/2005/gmd}PT_FreeText uses Python identifier PT_FreeText
    __PT_FreeText = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'PT_FreeText'), 'PT_FreeText', '__httpwww_isotc211_org2005gmd_PT_FreeText_PropertyType_httpwww_isotc211_org2005gmdPT_FreeText', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/freeText.xsd', 24, 1), )

    
    PT_FreeText = property(__PT_FreeText.value, __PT_FreeText.set, None, None)

    
    # Attribute nilReason inherited from {http://www.isotc211.org/2005/gco}CharacterString_PropertyType
    _ElementMap.update({
        __PT_FreeText.name() : __PT_FreeText
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.PT_FreeText_PropertyType = PT_FreeText_PropertyType
_Namespace_gmd.addCategoryObject('typeBinding', 'PT_FreeText_PropertyType', PT_FreeText_PropertyType)


# Complex type {http://www.isotc211.org/2005/gmd}LocalisedCharacterString_PropertyType with content type ELEMENT_ONLY
class LocalisedCharacterString_PropertyType (ObjectReference_PropertyType):
    """Complex type {http://www.isotc211.org/2005/gmd}LocalisedCharacterString_PropertyType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'LocalisedCharacterString_PropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/freeText.xsd', 69, 1)
    _ElementMap = ObjectReference_PropertyType._ElementMap.copy()
    _AttributeMap = ObjectReference_PropertyType._AttributeMap.copy()
    # Base type is ObjectReference_PropertyType
    
    # Element {http://www.isotc211.org/2005/gmd}LocalisedCharacterString uses Python identifier LocalisedCharacterString
    __LocalisedCharacterString = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'LocalisedCharacterString'), 'LocalisedCharacterString', '__httpwww_isotc211_org2005gmd_LocalisedCharacterString_PropertyType_httpwww_isotc211_org2005gmdLocalisedCharacterString', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/freeText.xsd', 67, 1), )

    
    LocalisedCharacterString = property(__LocalisedCharacterString.value, __LocalisedCharacterString.set, None, None)

    
    # Attribute uuidref inherited from {http://www.isotc211.org/2005/gco}ObjectReference_PropertyType
    
    # Attribute nilReason inherited from {http://www.isotc211.org/2005/gco}ObjectReference_PropertyType
    
    # Attribute type inherited from {http://www.isotc211.org/2005/gco}ObjectReference_PropertyType
    
    # Attribute href inherited from {http://www.isotc211.org/2005/gco}ObjectReference_PropertyType
    
    # Attribute role inherited from {http://www.isotc211.org/2005/gco}ObjectReference_PropertyType
    
    # Attribute arcrole inherited from {http://www.isotc211.org/2005/gco}ObjectReference_PropertyType
    
    # Attribute title inherited from {http://www.isotc211.org/2005/gco}ObjectReference_PropertyType
    
    # Attribute show inherited from {http://www.isotc211.org/2005/gco}ObjectReference_PropertyType
    
    # Attribute actuate inherited from {http://www.isotc211.org/2005/gco}ObjectReference_PropertyType
    _ElementMap.update({
        __LocalisedCharacterString.name() : __LocalisedCharacterString
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.LocalisedCharacterString_PropertyType = LocalisedCharacterString_PropertyType
_Namespace_gmd.addCategoryObject('typeBinding', 'LocalisedCharacterString_PropertyType', LocalisedCharacterString_PropertyType)


# Complex type {http://www.isotc211.org/2005/gmd}DS_Platform_Type with content type ELEMENT_ONLY
class DS_Platform_Type (DS_Series_Type):
    """Complex type {http://www.isotc211.org/2005/gmd}DS_Platform_Type with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'DS_Platform_Type')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataApplication.xsd', 112, 1)
    _ElementMap = DS_Series_Type._ElementMap.copy()
    _AttributeMap = DS_Series_Type._AttributeMap.copy()
    # Base type is DS_Series_Type
    
    # Element composedOf ({http://www.isotc211.org/2005/gmd}composedOf) inherited from {http://www.isotc211.org/2005/gmd}AbstractDS_Aggregate_Type
    
    # Element seriesMetadata ({http://www.isotc211.org/2005/gmd}seriesMetadata) inherited from {http://www.isotc211.org/2005/gmd}AbstractDS_Aggregate_Type
    
    # Element subset ({http://www.isotc211.org/2005/gmd}subset) inherited from {http://www.isotc211.org/2005/gmd}AbstractDS_Aggregate_Type
    
    # Element superset ({http://www.isotc211.org/2005/gmd}superset) inherited from {http://www.isotc211.org/2005/gmd}AbstractDS_Aggregate_Type
    
    # Attribute id inherited from {http://www.isotc211.org/2005/gco}AbstractObject_Type
    
    # Attribute uuid inherited from {http://www.isotc211.org/2005/gco}AbstractObject_Type
    _ElementMap.update({
        
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.DS_Platform_Type = DS_Platform_Type
_Namespace_gmd.addCategoryObject('typeBinding', 'DS_Platform_Type', DS_Platform_Type)


# Complex type {http://www.isotc211.org/2005/gmd}DS_Sensor_Type with content type ELEMENT_ONLY
class DS_Sensor_Type (DS_Series_Type):
    """Complex type {http://www.isotc211.org/2005/gmd}DS_Sensor_Type with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'DS_Sensor_Type')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataApplication.xsd', 128, 1)
    _ElementMap = DS_Series_Type._ElementMap.copy()
    _AttributeMap = DS_Series_Type._AttributeMap.copy()
    # Base type is DS_Series_Type
    
    # Element composedOf ({http://www.isotc211.org/2005/gmd}composedOf) inherited from {http://www.isotc211.org/2005/gmd}AbstractDS_Aggregate_Type
    
    # Element seriesMetadata ({http://www.isotc211.org/2005/gmd}seriesMetadata) inherited from {http://www.isotc211.org/2005/gmd}AbstractDS_Aggregate_Type
    
    # Element subset ({http://www.isotc211.org/2005/gmd}subset) inherited from {http://www.isotc211.org/2005/gmd}AbstractDS_Aggregate_Type
    
    # Element superset ({http://www.isotc211.org/2005/gmd}superset) inherited from {http://www.isotc211.org/2005/gmd}AbstractDS_Aggregate_Type
    
    # Attribute id inherited from {http://www.isotc211.org/2005/gco}AbstractObject_Type
    
    # Attribute uuid inherited from {http://www.isotc211.org/2005/gco}AbstractObject_Type
    _ElementMap.update({
        
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.DS_Sensor_Type = DS_Sensor_Type
_Namespace_gmd.addCategoryObject('typeBinding', 'DS_Sensor_Type', DS_Sensor_Type)


# Complex type {http://www.isotc211.org/2005/gmd}DS_ProductionSeries_Type with content type ELEMENT_ONLY
class DS_ProductionSeries_Type (DS_Series_Type):
    """Complex type {http://www.isotc211.org/2005/gmd}DS_ProductionSeries_Type with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'DS_ProductionSeries_Type')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataApplication.xsd', 144, 1)
    _ElementMap = DS_Series_Type._ElementMap.copy()
    _AttributeMap = DS_Series_Type._AttributeMap.copy()
    # Base type is DS_Series_Type
    
    # Element composedOf ({http://www.isotc211.org/2005/gmd}composedOf) inherited from {http://www.isotc211.org/2005/gmd}AbstractDS_Aggregate_Type
    
    # Element seriesMetadata ({http://www.isotc211.org/2005/gmd}seriesMetadata) inherited from {http://www.isotc211.org/2005/gmd}AbstractDS_Aggregate_Type
    
    # Element subset ({http://www.isotc211.org/2005/gmd}subset) inherited from {http://www.isotc211.org/2005/gmd}AbstractDS_Aggregate_Type
    
    # Element superset ({http://www.isotc211.org/2005/gmd}superset) inherited from {http://www.isotc211.org/2005/gmd}AbstractDS_Aggregate_Type
    
    # Attribute id inherited from {http://www.isotc211.org/2005/gco}AbstractObject_Type
    
    # Attribute uuid inherited from {http://www.isotc211.org/2005/gco}AbstractObject_Type
    _ElementMap.update({
        
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.DS_ProductionSeries_Type = DS_ProductionSeries_Type
_Namespace_gmd.addCategoryObject('typeBinding', 'DS_ProductionSeries_Type', DS_ProductionSeries_Type)


# Complex type {http://www.isotc211.org/2005/gmd}DS_StereoMate_Type with content type ELEMENT_ONLY
class DS_StereoMate_Type (DS_OtherAggregate_Type):
    """Complex type {http://www.isotc211.org/2005/gmd}DS_StereoMate_Type with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'DS_StereoMate_Type')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataApplication.xsd', 160, 1)
    _ElementMap = DS_OtherAggregate_Type._ElementMap.copy()
    _AttributeMap = DS_OtherAggregate_Type._AttributeMap.copy()
    # Base type is DS_OtherAggregate_Type
    
    # Element composedOf ({http://www.isotc211.org/2005/gmd}composedOf) inherited from {http://www.isotc211.org/2005/gmd}AbstractDS_Aggregate_Type
    
    # Element seriesMetadata ({http://www.isotc211.org/2005/gmd}seriesMetadata) inherited from {http://www.isotc211.org/2005/gmd}AbstractDS_Aggregate_Type
    
    # Element subset ({http://www.isotc211.org/2005/gmd}subset) inherited from {http://www.isotc211.org/2005/gmd}AbstractDS_Aggregate_Type
    
    # Element superset ({http://www.isotc211.org/2005/gmd}superset) inherited from {http://www.isotc211.org/2005/gmd}AbstractDS_Aggregate_Type
    
    # Attribute id inherited from {http://www.isotc211.org/2005/gco}AbstractObject_Type
    
    # Attribute uuid inherited from {http://www.isotc211.org/2005/gco}AbstractObject_Type
    _ElementMap.update({
        
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.DS_StereoMate_Type = DS_StereoMate_Type
_Namespace_gmd.addCategoryObject('typeBinding', 'DS_StereoMate_Type', DS_StereoMate_Type)


# Complex type {http://www.isotc211.org/2005/gmd}MD_Georeferenceable_Type with content type ELEMENT_ONLY
class MD_Georeferenceable_Type (MD_GridSpatialRepresentation_Type):
    """Complex type {http://www.isotc211.org/2005/gmd}MD_Georeferenceable_Type with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_Georeferenceable_Type')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/spatialRepresentation.xsd', 86, 1)
    _ElementMap = MD_GridSpatialRepresentation_Type._ElementMap.copy()
    _AttributeMap = MD_GridSpatialRepresentation_Type._AttributeMap.copy()
    # Base type is MD_GridSpatialRepresentation_Type
    
    # Element numberOfDimensions ({http://www.isotc211.org/2005/gmd}numberOfDimensions) inherited from {http://www.isotc211.org/2005/gmd}MD_GridSpatialRepresentation_Type
    
    # Element axisDimensionProperties ({http://www.isotc211.org/2005/gmd}axisDimensionProperties) inherited from {http://www.isotc211.org/2005/gmd}MD_GridSpatialRepresentation_Type
    
    # Element cellGeometry ({http://www.isotc211.org/2005/gmd}cellGeometry) inherited from {http://www.isotc211.org/2005/gmd}MD_GridSpatialRepresentation_Type
    
    # Element transformationParameterAvailability ({http://www.isotc211.org/2005/gmd}transformationParameterAvailability) inherited from {http://www.isotc211.org/2005/gmd}MD_GridSpatialRepresentation_Type
    
    # Element {http://www.isotc211.org/2005/gmd}controlPointAvailability uses Python identifier controlPointAvailability
    __controlPointAvailability = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'controlPointAvailability'), 'controlPointAvailability', '__httpwww_isotc211_org2005gmd_MD_Georeferenceable_Type_httpwww_isotc211_org2005gmdcontrolPointAvailability', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/spatialRepresentation.xsd', 90, 5), )

    
    controlPointAvailability = property(__controlPointAvailability.value, __controlPointAvailability.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}orientationParameterAvailability uses Python identifier orientationParameterAvailability
    __orientationParameterAvailability = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'orientationParameterAvailability'), 'orientationParameterAvailability', '__httpwww_isotc211_org2005gmd_MD_Georeferenceable_Type_httpwww_isotc211_org2005gmdorientationParameterAvailability', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/spatialRepresentation.xsd', 91, 5), )

    
    orientationParameterAvailability = property(__orientationParameterAvailability.value, __orientationParameterAvailability.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}orientationParameterDescription uses Python identifier orientationParameterDescription
    __orientationParameterDescription = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'orientationParameterDescription'), 'orientationParameterDescription', '__httpwww_isotc211_org2005gmd_MD_Georeferenceable_Type_httpwww_isotc211_org2005gmdorientationParameterDescription', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/spatialRepresentation.xsd', 92, 5), )

    
    orientationParameterDescription = property(__orientationParameterDescription.value, __orientationParameterDescription.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}georeferencedParameters uses Python identifier georeferencedParameters
    __georeferencedParameters = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'georeferencedParameters'), 'georeferencedParameters', '__httpwww_isotc211_org2005gmd_MD_Georeferenceable_Type_httpwww_isotc211_org2005gmdgeoreferencedParameters', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/spatialRepresentation.xsd', 93, 5), )

    
    georeferencedParameters = property(__georeferencedParameters.value, __georeferencedParameters.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}parameterCitation uses Python identifier parameterCitation
    __parameterCitation = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'parameterCitation'), 'parameterCitation', '__httpwww_isotc211_org2005gmd_MD_Georeferenceable_Type_httpwww_isotc211_org2005gmdparameterCitation', True, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/spatialRepresentation.xsd', 94, 5), )

    
    parameterCitation = property(__parameterCitation.value, __parameterCitation.set, None, None)

    
    # Attribute id inherited from {http://www.isotc211.org/2005/gco}AbstractObject_Type
    
    # Attribute uuid inherited from {http://www.isotc211.org/2005/gco}AbstractObject_Type
    _ElementMap.update({
        __controlPointAvailability.name() : __controlPointAvailability,
        __orientationParameterAvailability.name() : __orientationParameterAvailability,
        __orientationParameterDescription.name() : __orientationParameterDescription,
        __georeferencedParameters.name() : __georeferencedParameters,
        __parameterCitation.name() : __parameterCitation
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.MD_Georeferenceable_Type = MD_Georeferenceable_Type
_Namespace_gmd.addCategoryObject('typeBinding', 'MD_Georeferenceable_Type', MD_Georeferenceable_Type)


# Complex type {http://www.isotc211.org/2005/gmd}MD_Georectified_Type with content type ELEMENT_ONLY
class MD_Georectified_Type (MD_GridSpatialRepresentation_Type):
    """Complex type {http://www.isotc211.org/2005/gmd}MD_Georectified_Type with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_Georectified_Type')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/spatialRepresentation.xsd', 132, 1)
    _ElementMap = MD_GridSpatialRepresentation_Type._ElementMap.copy()
    _AttributeMap = MD_GridSpatialRepresentation_Type._AttributeMap.copy()
    # Base type is MD_GridSpatialRepresentation_Type
    
    # Element numberOfDimensions ({http://www.isotc211.org/2005/gmd}numberOfDimensions) inherited from {http://www.isotc211.org/2005/gmd}MD_GridSpatialRepresentation_Type
    
    # Element axisDimensionProperties ({http://www.isotc211.org/2005/gmd}axisDimensionProperties) inherited from {http://www.isotc211.org/2005/gmd}MD_GridSpatialRepresentation_Type
    
    # Element cellGeometry ({http://www.isotc211.org/2005/gmd}cellGeometry) inherited from {http://www.isotc211.org/2005/gmd}MD_GridSpatialRepresentation_Type
    
    # Element transformationParameterAvailability ({http://www.isotc211.org/2005/gmd}transformationParameterAvailability) inherited from {http://www.isotc211.org/2005/gmd}MD_GridSpatialRepresentation_Type
    
    # Element {http://www.isotc211.org/2005/gmd}checkPointAvailability uses Python identifier checkPointAvailability
    __checkPointAvailability = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'checkPointAvailability'), 'checkPointAvailability', '__httpwww_isotc211_org2005gmd_MD_Georectified_Type_httpwww_isotc211_org2005gmdcheckPointAvailability', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/spatialRepresentation.xsd', 136, 5), )

    
    checkPointAvailability = property(__checkPointAvailability.value, __checkPointAvailability.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}checkPointDescription uses Python identifier checkPointDescription
    __checkPointDescription = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'checkPointDescription'), 'checkPointDescription', '__httpwww_isotc211_org2005gmd_MD_Georectified_Type_httpwww_isotc211_org2005gmdcheckPointDescription', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/spatialRepresentation.xsd', 137, 5), )

    
    checkPointDescription = property(__checkPointDescription.value, __checkPointDescription.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}cornerPoints uses Python identifier cornerPoints
    __cornerPoints = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'cornerPoints'), 'cornerPoints', '__httpwww_isotc211_org2005gmd_MD_Georectified_Type_httpwww_isotc211_org2005gmdcornerPoints', True, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/spatialRepresentation.xsd', 138, 5), )

    
    cornerPoints = property(__cornerPoints.value, __cornerPoints.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}centerPoint uses Python identifier centerPoint
    __centerPoint = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'centerPoint'), 'centerPoint', '__httpwww_isotc211_org2005gmd_MD_Georectified_Type_httpwww_isotc211_org2005gmdcenterPoint', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/spatialRepresentation.xsd', 139, 5), )

    
    centerPoint = property(__centerPoint.value, __centerPoint.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}pointInPixel uses Python identifier pointInPixel
    __pointInPixel = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'pointInPixel'), 'pointInPixel', '__httpwww_isotc211_org2005gmd_MD_Georectified_Type_httpwww_isotc211_org2005gmdpointInPixel', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/spatialRepresentation.xsd', 140, 5), )

    
    pointInPixel = property(__pointInPixel.value, __pointInPixel.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}transformationDimensionDescription uses Python identifier transformationDimensionDescription
    __transformationDimensionDescription = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'transformationDimensionDescription'), 'transformationDimensionDescription', '__httpwww_isotc211_org2005gmd_MD_Georectified_Type_httpwww_isotc211_org2005gmdtransformationDimensionDescription', False, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/spatialRepresentation.xsd', 141, 5), )

    
    transformationDimensionDescription = property(__transformationDimensionDescription.value, __transformationDimensionDescription.set, None, None)

    
    # Element {http://www.isotc211.org/2005/gmd}transformationDimensionMapping uses Python identifier transformationDimensionMapping
    __transformationDimensionMapping = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gmd, 'transformationDimensionMapping'), 'transformationDimensionMapping', '__httpwww_isotc211_org2005gmd_MD_Georectified_Type_httpwww_isotc211_org2005gmdtransformationDimensionMapping', True, pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/spatialRepresentation.xsd', 142, 5), )

    
    transformationDimensionMapping = property(__transformationDimensionMapping.value, __transformationDimensionMapping.set, None, None)

    
    # Attribute id inherited from {http://www.isotc211.org/2005/gco}AbstractObject_Type
    
    # Attribute uuid inherited from {http://www.isotc211.org/2005/gco}AbstractObject_Type
    _ElementMap.update({
        __checkPointAvailability.name() : __checkPointAvailability,
        __checkPointDescription.name() : __checkPointDescription,
        __cornerPoints.name() : __cornerPoints,
        __centerPoint.name() : __centerPoint,
        __pointInPixel.name() : __pointInPixel,
        __transformationDimensionDescription.name() : __transformationDimensionDescription,
        __transformationDimensionMapping.name() : __transformationDimensionMapping
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.MD_Georectified_Type = MD_Georectified_Type
_Namespace_gmd.addCategoryObject('typeBinding', 'MD_Georectified_Type', MD_Georectified_Type)


# Complex type {http://www.opengis.net/gml/3.2}CodeOrNilReasonListType with content type SIMPLE
class CodeOrNilReasonListType (pyxb.binding.basis.complexTypeDefinition):
    """gml:CodeOrNilReasonListType provides for lists of terms. The values in an instance element shall all be valid according to the rules of the dictionary, classification scheme, or authority identified by the value of its codeSpace attribute. An instance element may also include embedded values from NilReasonType. It is intended to be used in situations where a term or classification is expected, but the value may be absent for some reason."""
    _TypeDefinition = NameOrNilReasonList
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_SIMPLE
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'CodeOrNilReasonListType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/basicTypes.xsd', 238, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is NameOrNilReasonList
    
    # Attribute codeSpace uses Python identifier codeSpace
    __codeSpace = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'codeSpace'), 'codeSpace', '__httpwww_opengis_netgml3_2_CodeOrNilReasonListType_codeSpace', pyxb.binding.datatypes.anyURI)
    __codeSpace._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/basicTypes.xsd', 244, 4)
    __codeSpace._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/basicTypes.xsd', 244, 4)
    
    codeSpace = property(__codeSpace.value, __codeSpace.set, None, None)

    _ElementMap.update({
        
    })
    _AttributeMap.update({
        __codeSpace.name() : __codeSpace
    })
_module_typeBindings.CodeOrNilReasonListType = CodeOrNilReasonListType
_Namespace_gml.addCategoryObject('typeBinding', 'CodeOrNilReasonListType', CodeOrNilReasonListType)


# Complex type {http://www.opengis.net/gml/3.2}MeasureOrNilReasonListType with content type SIMPLE
class MeasureOrNilReasonListType (pyxb.binding.basis.complexTypeDefinition):
    """gml:MeasureOrNilReasonListType provides for a list of quantities. An instance element may also include embedded values from NilReasonType. It is intended to be used in situations where a value is expected, but the value may be absent for some reason."""
    _TypeDefinition = doubleOrNilReasonList
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_SIMPLE
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'MeasureOrNilReasonListType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/basicTypes.xsd', 258, 1)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is doubleOrNilReasonList
    
    # Attribute uom uses Python identifier uom
    __uom = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'uom'), 'uom', '__httpwww_opengis_netgml3_2_MeasureOrNilReasonListType_uom', _module_typeBindings.UomIdentifier, required=True)
    __uom._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/basicTypes.xsd', 264, 4)
    __uom._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/basicTypes.xsd', 264, 4)
    
    uom = property(__uom.value, __uom.set, None, None)

    _ElementMap.update({
        
    })
    _AttributeMap.update({
        __uom.name() : __uom
    })
_module_typeBindings.MeasureOrNilReasonListType = MeasureOrNilReasonListType
_Namespace_gml.addCategoryObject('typeBinding', 'MeasureOrNilReasonListType', MeasureOrNilReasonListType)


# Complex type {http://www.opengis.net/gml/3.2}DiscreteCoverageType with content type ELEMENT_ONLY
class DiscreteCoverageType (AbstractCoverageType):
    """Complex type {http://www.opengis.net/gml/3.2}DiscreteCoverageType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'DiscreteCoverageType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coverage.xsd', 39, 1)
    _ElementMap = AbstractCoverageType._ElementMap.copy()
    _AttributeMap = AbstractCoverageType._AttributeMap.copy()
    # Base type is AbstractCoverageType
    
    # Element domainSet ({http://www.opengis.net/gml/3.2}domainSet) inherited from {http://www.opengis.net/gml/3.2}AbstractCoverageType
    
    # Element rangeSet ({http://www.opengis.net/gml/3.2}rangeSet) inherited from {http://www.opengis.net/gml/3.2}AbstractCoverageType
    
    # Element {http://www.opengis.net/gml/3.2}coverageFunction uses Python identifier coverageFunction
    __coverageFunction = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'coverageFunction'), 'coverageFunction', '__httpwww_opengis_netgml3_2_DiscreteCoverageType_httpwww_opengis_netgml3_2coverageFunction', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coverage.xsd', 158, 1), )

    
    coverageFunction = property(__coverageFunction.value, __coverageFunction.set, None, 'The gml:coverageFunction property describes the mapping function from the domain to the range of the coverage.\nThe value of the CoverageFunction is one of gml:CoverageMappingRule and gml:GridFunction.\nIf the gml:coverageFunction property is omitted for a gridded coverage (including rectified gridded coverages) the gml:startPoint is assumed to be the value of the gml:low property in the gml:Grid geometry, and the gml:sequenceRule is assumed to be linear and the gml:axisOrder property is assumed to be "+1 +2".')

    
    # Element metaDataProperty ({http://www.opengis.net/gml/3.2}metaDataProperty) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element location ({http://www.opengis.net/gml/3.2}location) inherited from {http://www.opengis.net/gml/3.2}AbstractFeatureType
    
    # Element boundedBy ({http://www.opengis.net/gml/3.2}boundedBy) inherited from {http://www.opengis.net/gml/3.2}AbstractFeatureType
    
    # Element description ({http://www.opengis.net/gml/3.2}description) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element descriptionReference ({http://www.opengis.net/gml/3.2}descriptionReference) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element name ({http://www.opengis.net/gml/3.2}name) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element identifier ({http://www.opengis.net/gml/3.2}identifier) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Attribute id inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    _ElementMap.update({
        __coverageFunction.name() : __coverageFunction
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.DiscreteCoverageType = DiscreteCoverageType
_Namespace_gml.addCategoryObject('typeBinding', 'DiscreteCoverageType', DiscreteCoverageType)


# Complex type {http://www.opengis.net/gml/3.2}AbstractContinuousCoverageType with content type ELEMENT_ONLY
class AbstractContinuousCoverageType (AbstractCoverageType):
    """Complex type {http://www.opengis.net/gml/3.2}AbstractContinuousCoverageType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = True
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractContinuousCoverageType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coverage.xsd', 54, 1)
    _ElementMap = AbstractCoverageType._ElementMap.copy()
    _AttributeMap = AbstractCoverageType._AttributeMap.copy()
    # Base type is AbstractCoverageType
    
    # Element domainSet ({http://www.opengis.net/gml/3.2}domainSet) inherited from {http://www.opengis.net/gml/3.2}AbstractCoverageType
    
    # Element rangeSet ({http://www.opengis.net/gml/3.2}rangeSet) inherited from {http://www.opengis.net/gml/3.2}AbstractCoverageType
    
    # Element {http://www.opengis.net/gml/3.2}coverageFunction uses Python identifier coverageFunction
    __coverageFunction = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'coverageFunction'), 'coverageFunction', '__httpwww_opengis_netgml3_2_AbstractContinuousCoverageType_httpwww_opengis_netgml3_2coverageFunction', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coverage.xsd', 158, 1), )

    
    coverageFunction = property(__coverageFunction.value, __coverageFunction.set, None, 'The gml:coverageFunction property describes the mapping function from the domain to the range of the coverage.\nThe value of the CoverageFunction is one of gml:CoverageMappingRule and gml:GridFunction.\nIf the gml:coverageFunction property is omitted for a gridded coverage (including rectified gridded coverages) the gml:startPoint is assumed to be the value of the gml:low property in the gml:Grid geometry, and the gml:sequenceRule is assumed to be linear and the gml:axisOrder property is assumed to be "+1 +2".')

    
    # Element metaDataProperty ({http://www.opengis.net/gml/3.2}metaDataProperty) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element location ({http://www.opengis.net/gml/3.2}location) inherited from {http://www.opengis.net/gml/3.2}AbstractFeatureType
    
    # Element boundedBy ({http://www.opengis.net/gml/3.2}boundedBy) inherited from {http://www.opengis.net/gml/3.2}AbstractFeatureType
    
    # Element description ({http://www.opengis.net/gml/3.2}description) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element descriptionReference ({http://www.opengis.net/gml/3.2}descriptionReference) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element name ({http://www.opengis.net/gml/3.2}name) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element identifier ({http://www.opengis.net/gml/3.2}identifier) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Attribute id inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    _ElementMap.update({
        __coverageFunction.name() : __coverageFunction
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.AbstractContinuousCoverageType = AbstractContinuousCoverageType
_Namespace_gml.addCategoryObject('typeBinding', 'AbstractContinuousCoverageType', AbstractContinuousCoverageType)


# Complex type {http://www.opengis.net/gml/3.2}PriorityLocationPropertyType with content type ELEMENT_ONLY
class PriorityLocationPropertyType (LocationPropertyType):
    """"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'PriorityLocationPropertyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 795, 1)
    _ElementMap = LocationPropertyType._ElementMap.copy()
    _AttributeMap = LocationPropertyType._AttributeMap.copy()
    # Base type is LocationPropertyType
    
    # Element Null ({http://www.opengis.net/gml/3.2}Null) inherited from {http://www.opengis.net/gml/3.2}LocationPropertyType
    
    # Element LocationString ({http://www.opengis.net/gml/3.2}LocationString) inherited from {http://www.opengis.net/gml/3.2}LocationPropertyType
    
    # Element LocationKeyWord ({http://www.opengis.net/gml/3.2}LocationKeyWord) inherited from {http://www.opengis.net/gml/3.2}LocationPropertyType
    
    # Element AbstractGeometry ({http://www.opengis.net/gml/3.2}AbstractGeometry) inherited from {http://www.opengis.net/gml/3.2}LocationPropertyType
    
    # Attribute remoteSchema inherited from {http://www.opengis.net/gml/3.2}LocationPropertyType
    
    # Attribute priority uses Python identifier priority
    __priority = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'priority'), 'priority', '__httpwww_opengis_netgml3_2_PriorityLocationPropertyType_priority', pyxb.binding.datatypes.string)
    __priority._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 801, 4)
    __priority._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 801, 4)
    
    priority = property(__priority.value, __priority.set, None, None)

    
    # Attribute nilReason inherited from {http://www.opengis.net/gml/3.2}LocationPropertyType
    
    # Attribute type inherited from {http://www.opengis.net/gml/3.2}LocationPropertyType
    
    # Attribute href inherited from {http://www.opengis.net/gml/3.2}LocationPropertyType
    
    # Attribute role inherited from {http://www.opengis.net/gml/3.2}LocationPropertyType
    
    # Attribute arcrole inherited from {http://www.opengis.net/gml/3.2}LocationPropertyType
    
    # Attribute title inherited from {http://www.opengis.net/gml/3.2}LocationPropertyType
    
    # Attribute show inherited from {http://www.opengis.net/gml/3.2}LocationPropertyType
    
    # Attribute actuate inherited from {http://www.opengis.net/gml/3.2}LocationPropertyType
    _ElementMap.update({
        
    })
    _AttributeMap.update({
        __priority.name() : __priority
    })
_module_typeBindings.PriorityLocationPropertyType = PriorityLocationPropertyType
_Namespace_gml.addCategoryObject('typeBinding', 'PriorityLocationPropertyType', PriorityLocationPropertyType)


# Complex type {http://www.opengis.net/gml/3.2}FeatureCollectionType with content type ELEMENT_ONLY
class FeatureCollectionType (AbstractFeatureCollectionType):
    """"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'FeatureCollectionType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 865, 1)
    _ElementMap = AbstractFeatureCollectionType._ElementMap.copy()
    _AttributeMap = AbstractFeatureCollectionType._AttributeMap.copy()
    # Base type is AbstractFeatureCollectionType
    
    # Element metaDataProperty ({http://www.opengis.net/gml/3.2}metaDataProperty) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element location ({http://www.opengis.net/gml/3.2}location) inherited from {http://www.opengis.net/gml/3.2}AbstractFeatureType
    
    # Element featureMember ({http://www.opengis.net/gml/3.2}featureMember) inherited from {http://www.opengis.net/gml/3.2}AbstractFeatureCollectionType
    
    # Element featureMembers ({http://www.opengis.net/gml/3.2}featureMembers) inherited from {http://www.opengis.net/gml/3.2}AbstractFeatureCollectionType
    
    # Element boundedBy ({http://www.opengis.net/gml/3.2}boundedBy) inherited from {http://www.opengis.net/gml/3.2}AbstractFeatureType
    
    # Element description ({http://www.opengis.net/gml/3.2}description) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element descriptionReference ({http://www.opengis.net/gml/3.2}descriptionReference) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element name ({http://www.opengis.net/gml/3.2}name) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element identifier ({http://www.opengis.net/gml/3.2}identifier) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Attribute id inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    _ElementMap.update({
        
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.FeatureCollectionType = FeatureCollectionType
_Namespace_gml.addCategoryObject('typeBinding', 'FeatureCollectionType', FeatureCollectionType)


# Complex type {http://www.opengis.net/gml/3.2}DefinitionProxyType with content type ELEMENT_ONLY
class DefinitionProxyType (DefinitionType):
    """"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'DefinitionProxyType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 906, 1)
    _ElementMap = DefinitionType._ElementMap.copy()
    _AttributeMap = DefinitionType._AttributeMap.copy()
    # Base type is DefinitionType
    
    # Element metaDataProperty ({http://www.opengis.net/gml/3.2}metaDataProperty) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element {http://www.opengis.net/gml/3.2}definitionRef uses Python identifier definitionRef
    __definitionRef = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'definitionRef'), 'definitionRef', '__httpwww_opengis_netgml3_2_DefinitionProxyType_httpwww_opengis_netgml3_2definitionRef', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 918, 1), )

    
    definitionRef = property(__definitionRef.value, __definitionRef.set, None, '')

    
    # Element remarks ({http://www.opengis.net/gml/3.2}remarks) inherited from {http://www.opengis.net/gml/3.2}DefinitionType
    
    # Element description ({http://www.opengis.net/gml/3.2}description) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element descriptionReference ({http://www.opengis.net/gml/3.2}descriptionReference) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element name ({http://www.opengis.net/gml/3.2}name) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element identifier ({http://www.opengis.net/gml/3.2}identifier) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Attribute id_ inherited from {http://www.opengis.net/gml/3.2}DefinitionBaseType
    _ElementMap.update({
        __definitionRef.name() : __definitionRef
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.DefinitionProxyType = DefinitionProxyType
_Namespace_gml.addCategoryObject('typeBinding', 'DefinitionProxyType', DefinitionProxyType)


# Complex type {http://www.opengis.net/gml/3.2}DictionaryType with content type ELEMENT_ONLY
class DictionaryType (DefinitionType):
    """Complex type {http://www.opengis.net/gml/3.2}DictionaryType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'DictionaryType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 62, 1)
    _ElementMap = DefinitionType._ElementMap.copy()
    _AttributeMap = DefinitionType._AttributeMap.copy()
    # Base type is DefinitionType
    
    # Element metaDataProperty ({http://www.opengis.net/gml/3.2}metaDataProperty) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element {http://www.opengis.net/gml/3.2}indirectEntry uses Python identifier indirectEntry
    __indirectEntry = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'indirectEntry'), 'indirectEntry', '__httpwww_opengis_netgml3_2_DictionaryType_httpwww_opengis_netgml3_2indirectEntry', True, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 888, 1), )

    
    indirectEntry = property(__indirectEntry.value, __indirectEntry.set, None, '')

    
    # Element remarks ({http://www.opengis.net/gml/3.2}remarks) inherited from {http://www.opengis.net/gml/3.2}DefinitionType
    
    # Element {http://www.opengis.net/gml/3.2}dictionaryEntry uses Python identifier dictionaryEntry
    __dictionaryEntry = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'dictionaryEntry'), 'dictionaryEntry', '__httpwww_opengis_netgml3_2_DictionaryType_httpwww_opengis_netgml3_2dictionaryEntry', True, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 73, 1), )

    
    dictionaryEntry = property(__dictionaryEntry.value, __dictionaryEntry.set, None, 'This property element contains or refers to the definitions which are members of a dictionary. \nThe content model follows the standard GML property pattern, so a gml:dictionaryEntry may either contain or refer to a single gml:Definition. Since gml:Dictionary is substitutable for gml:Definition, the content of an entry may itself be a lower level dictionary. \nNote that if the value is provided by reference, this definition does not carry a handle (gml:id) in this context, so does not allow external references to this specific definition in this context.  When used in this way the referenced definition will usually be in a dictionary in the same XML document.')

    
    # Element description ({http://www.opengis.net/gml/3.2}description) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element descriptionReference ({http://www.opengis.net/gml/3.2}descriptionReference) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element name ({http://www.opengis.net/gml/3.2}name) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element identifier ({http://www.opengis.net/gml/3.2}identifier) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Attribute id_ inherited from {http://www.opengis.net/gml/3.2}DefinitionBaseType
    
    # Attribute aggregationType uses Python identifier aggregationType
    __aggregationType = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'aggregationType'), 'aggregationType', '__httpwww_opengis_netgml3_2_DictionaryType_aggregationType', _module_typeBindings.AggregationType)
    __aggregationType._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 158, 2)
    __aggregationType._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 158, 2)
    
    aggregationType = property(__aggregationType.value, __aggregationType.set, None, None)

    _ElementMap.update({
        __indirectEntry.name() : __indirectEntry,
        __dictionaryEntry.name() : __dictionaryEntry
    })
    _AttributeMap.update({
        __aggregationType.name() : __aggregationType
    })
_module_typeBindings.DictionaryType = DictionaryType
_Namespace_gml.addCategoryObject('typeBinding', 'DictionaryType', DictionaryType)


# Complex type {http://www.opengis.net/gml/3.2}DynamicFeatureCollectionType with content type ELEMENT_ONLY
class DynamicFeatureCollectionType (DynamicFeatureType):
    """Complex type {http://www.opengis.net/gml/3.2}DynamicFeatureCollectionType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'DynamicFeatureCollectionType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dynamicFeature.xsd', 58, 1)
    _ElementMap = DynamicFeatureType._ElementMap.copy()
    _AttributeMap = DynamicFeatureType._AttributeMap.copy()
    # Base type is DynamicFeatureType
    
    # Element metaDataProperty ({http://www.opengis.net/gml/3.2}metaDataProperty) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element location ({http://www.opengis.net/gml/3.2}location) inherited from {http://www.opengis.net/gml/3.2}AbstractFeatureType
    
    # Element dataSource ({http://www.opengis.net/gml/3.2}dataSource) inherited from {http://www.opengis.net/gml/3.2}DynamicFeatureType
    
    # Element dataSourceReference ({http://www.opengis.net/gml/3.2}dataSourceReference) inherited from {http://www.opengis.net/gml/3.2}DynamicFeatureType
    
    # Element {http://www.opengis.net/gml/3.2}dynamicMembers uses Python identifier dynamicMembers
    __dynamicMembers = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'dynamicMembers'), 'dynamicMembers', '__httpwww_opengis_netgml3_2_DynamicFeatureCollectionType_httpwww_opengis_netgml3_2dynamicMembers', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dynamicFeature.xsd', 67, 1), )

    
    dynamicMembers = property(__dynamicMembers.value, __dynamicMembers.set, None, None)

    
    # Element history ({http://www.opengis.net/gml/3.2}history) inherited from {http://www.opengis.net/gml/3.2}DynamicFeatureType
    
    # Element boundedBy ({http://www.opengis.net/gml/3.2}boundedBy) inherited from {http://www.opengis.net/gml/3.2}AbstractFeatureType
    
    # Element description ({http://www.opengis.net/gml/3.2}description) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element descriptionReference ({http://www.opengis.net/gml/3.2}descriptionReference) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element name ({http://www.opengis.net/gml/3.2}name) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element identifier ({http://www.opengis.net/gml/3.2}identifier) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element validTime ({http://www.opengis.net/gml/3.2}validTime) inherited from {http://www.opengis.net/gml/3.2}DynamicFeatureType
    
    # Attribute id inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    _ElementMap.update({
        __dynamicMembers.name() : __dynamicMembers
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.DynamicFeatureCollectionType = DynamicFeatureCollectionType
_Namespace_gml.addCategoryObject('typeBinding', 'DynamicFeatureCollectionType', DynamicFeatureCollectionType)


# Complex type {http://www.opengis.net/gml/3.2}MultiGeometryType with content type ELEMENT_ONLY
class MultiGeometryType (AbstractGeometricAggregateType):
    """Complex type {http://www.opengis.net/gml/3.2}MultiGeometryType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'MultiGeometryType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryAggregates.xsd', 27, 1)
    _ElementMap = AbstractGeometricAggregateType._ElementMap.copy()
    _AttributeMap = AbstractGeometricAggregateType._AttributeMap.copy()
    # Base type is AbstractGeometricAggregateType
    
    # Element metaDataProperty ({http://www.opengis.net/gml/3.2}metaDataProperty) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element {http://www.opengis.net/gml/3.2}geometryMember uses Python identifier geometryMember
    __geometryMember = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'geometryMember'), 'geometryMember', '__httpwww_opengis_netgml3_2_MultiGeometryType_httpwww_opengis_netgml3_2geometryMember', True, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryAggregates.xsd', 43, 1), )

    
    geometryMember = property(__geometryMember.value, __geometryMember.set, None, 'This property element either references a geometry element via the XLink-attributes or contains the geometry element.')

    
    # Element {http://www.opengis.net/gml/3.2}geometryMembers uses Python identifier geometryMembers
    __geometryMembers = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'geometryMembers'), 'geometryMembers', '__httpwww_opengis_netgml3_2_MultiGeometryType_httpwww_opengis_netgml3_2geometryMembers', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryAggregates.xsd', 48, 1), )

    
    geometryMembers = property(__geometryMembers.value, __geometryMembers.set, None, 'This property element contains a list of geometry elements. The order of the elements is significant and shall be preserved when processing the array.')

    
    # Element description ({http://www.opengis.net/gml/3.2}description) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element descriptionReference ({http://www.opengis.net/gml/3.2}descriptionReference) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element name ({http://www.opengis.net/gml/3.2}name) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element identifier ({http://www.opengis.net/gml/3.2}identifier) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Attribute srsName inherited from {http://www.opengis.net/gml/3.2}AbstractGeometryType
    
    # Attribute srsDimension inherited from {http://www.opengis.net/gml/3.2}AbstractGeometryType
    
    # Attribute axisLabels inherited from {http://www.opengis.net/gml/3.2}AbstractGeometryType
    
    # Attribute uomLabels inherited from {http://www.opengis.net/gml/3.2}AbstractGeometryType
    
    # Attribute id inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Attribute aggregationType inherited from {http://www.opengis.net/gml/3.2}AbstractGeometricAggregateType
    _ElementMap.update({
        __geometryMember.name() : __geometryMember,
        __geometryMembers.name() : __geometryMembers
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.MultiGeometryType = MultiGeometryType
_Namespace_gml.addCategoryObject('typeBinding', 'MultiGeometryType', MultiGeometryType)


# Complex type {http://www.opengis.net/gml/3.2}MultiPointType with content type ELEMENT_ONLY
class MultiPointType (AbstractGeometricAggregateType):
    """Complex type {http://www.opengis.net/gml/3.2}MultiPointType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'MultiPointType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryAggregates.xsd', 63, 1)
    _ElementMap = AbstractGeometricAggregateType._ElementMap.copy()
    _AttributeMap = AbstractGeometricAggregateType._AttributeMap.copy()
    # Base type is AbstractGeometricAggregateType
    
    # Element metaDataProperty ({http://www.opengis.net/gml/3.2}metaDataProperty) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element {http://www.opengis.net/gml/3.2}pointMember uses Python identifier pointMember
    __pointMember = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'pointMember'), 'pointMember', '__httpwww_opengis_netgml3_2_MultiPointType_httpwww_opengis_netgml3_2pointMember', True, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryAggregates.xsd', 79, 1), )

    
    pointMember = property(__pointMember.value, __pointMember.set, None, 'This property element either references a Point via the XLink-attributes or contains the Point element.')

    
    # Element {http://www.opengis.net/gml/3.2}pointMembers uses Python identifier pointMembers
    __pointMembers = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'pointMembers'), 'pointMembers', '__httpwww_opengis_netgml3_2_MultiPointType_httpwww_opengis_netgml3_2pointMembers', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryAggregates.xsd', 84, 1), )

    
    pointMembers = property(__pointMembers.value, __pointMembers.set, None, 'This property element contains a list of points. The order of the elements is significant and shall be preserved when processing the array.')

    
    # Element description ({http://www.opengis.net/gml/3.2}description) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element descriptionReference ({http://www.opengis.net/gml/3.2}descriptionReference) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element name ({http://www.opengis.net/gml/3.2}name) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element identifier ({http://www.opengis.net/gml/3.2}identifier) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Attribute srsName inherited from {http://www.opengis.net/gml/3.2}AbstractGeometryType
    
    # Attribute srsDimension inherited from {http://www.opengis.net/gml/3.2}AbstractGeometryType
    
    # Attribute axisLabels inherited from {http://www.opengis.net/gml/3.2}AbstractGeometryType
    
    # Attribute uomLabels inherited from {http://www.opengis.net/gml/3.2}AbstractGeometryType
    
    # Attribute id inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Attribute aggregationType inherited from {http://www.opengis.net/gml/3.2}AbstractGeometricAggregateType
    _ElementMap.update({
        __pointMember.name() : __pointMember,
        __pointMembers.name() : __pointMembers
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.MultiPointType = MultiPointType
_Namespace_gml.addCategoryObject('typeBinding', 'MultiPointType', MultiPointType)


# Complex type {http://www.opengis.net/gml/3.2}MultiCurveType with content type ELEMENT_ONLY
class MultiCurveType (AbstractGeometricAggregateType):
    """Complex type {http://www.opengis.net/gml/3.2}MultiCurveType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'MultiCurveType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryAggregates.xsd', 99, 1)
    _ElementMap = AbstractGeometricAggregateType._ElementMap.copy()
    _AttributeMap = AbstractGeometricAggregateType._AttributeMap.copy()
    # Base type is AbstractGeometricAggregateType
    
    # Element metaDataProperty ({http://www.opengis.net/gml/3.2}metaDataProperty) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element {http://www.opengis.net/gml/3.2}curveMembers uses Python identifier curveMembers
    __curveMembers = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'curveMembers'), 'curveMembers', '__httpwww_opengis_netgml3_2_MultiCurveType_httpwww_opengis_netgml3_2curveMembers', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryAggregates.xsd', 115, 1), )

    
    curveMembers = property(__curveMembers.value, __curveMembers.set, None, 'This property element contains a list of curves. The order of the elements is significant and shall be preserved when processing the array.')

    
    # Element {http://www.opengis.net/gml/3.2}curveMember uses Python identifier curveMember
    __curveMember = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'curveMember'), 'curveMember', '__httpwww_opengis_netgml3_2_MultiCurveType_httpwww_opengis_netgml3_2curveMember', True, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 639, 1), )

    
    curveMember = property(__curveMember.value, __curveMember.set, None, None)

    
    # Element description ({http://www.opengis.net/gml/3.2}description) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element descriptionReference ({http://www.opengis.net/gml/3.2}descriptionReference) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element name ({http://www.opengis.net/gml/3.2}name) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element identifier ({http://www.opengis.net/gml/3.2}identifier) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Attribute srsName inherited from {http://www.opengis.net/gml/3.2}AbstractGeometryType
    
    # Attribute srsDimension inherited from {http://www.opengis.net/gml/3.2}AbstractGeometryType
    
    # Attribute axisLabels inherited from {http://www.opengis.net/gml/3.2}AbstractGeometryType
    
    # Attribute uomLabels inherited from {http://www.opengis.net/gml/3.2}AbstractGeometryType
    
    # Attribute id inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Attribute aggregationType inherited from {http://www.opengis.net/gml/3.2}AbstractGeometricAggregateType
    _ElementMap.update({
        __curveMembers.name() : __curveMembers,
        __curveMember.name() : __curveMember
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.MultiCurveType = MultiCurveType
_Namespace_gml.addCategoryObject('typeBinding', 'MultiCurveType', MultiCurveType)


# Complex type {http://www.opengis.net/gml/3.2}MultiSurfaceType with content type ELEMENT_ONLY
class MultiSurfaceType (AbstractGeometricAggregateType):
    """Complex type {http://www.opengis.net/gml/3.2}MultiSurfaceType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'MultiSurfaceType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryAggregates.xsd', 130, 1)
    _ElementMap = AbstractGeometricAggregateType._ElementMap.copy()
    _AttributeMap = AbstractGeometricAggregateType._AttributeMap.copy()
    # Base type is AbstractGeometricAggregateType
    
    # Element metaDataProperty ({http://www.opengis.net/gml/3.2}metaDataProperty) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element {http://www.opengis.net/gml/3.2}surfaceMembers uses Python identifier surfaceMembers
    __surfaceMembers = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'surfaceMembers'), 'surfaceMembers', '__httpwww_opengis_netgml3_2_MultiSurfaceType_httpwww_opengis_netgml3_2surfaceMembers', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryAggregates.xsd', 146, 1), )

    
    surfaceMembers = property(__surfaceMembers.value, __surfaceMembers.set, None, 'This property element contains a list of surfaces. The order of the elements is significant and shall be preserved when processing the array.')

    
    # Element {http://www.opengis.net/gml/3.2}surfaceMember uses Python identifier surfaceMember
    __surfaceMember = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'surfaceMember'), 'surfaceMember', '__httpwww_opengis_netgml3_2_MultiSurfaceType_httpwww_opengis_netgml3_2surfaceMember', True, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 837, 1), )

    
    surfaceMember = property(__surfaceMember.value, __surfaceMember.set, None, 'This property element either references a surface via the XLink-attributes or contains the surface element. A surface element is any element, which is substitutable for gml:AbstractSurface.')

    
    # Element description ({http://www.opengis.net/gml/3.2}description) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element descriptionReference ({http://www.opengis.net/gml/3.2}descriptionReference) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element name ({http://www.opengis.net/gml/3.2}name) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element identifier ({http://www.opengis.net/gml/3.2}identifier) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Attribute srsName inherited from {http://www.opengis.net/gml/3.2}AbstractGeometryType
    
    # Attribute srsDimension inherited from {http://www.opengis.net/gml/3.2}AbstractGeometryType
    
    # Attribute axisLabels inherited from {http://www.opengis.net/gml/3.2}AbstractGeometryType
    
    # Attribute uomLabels inherited from {http://www.opengis.net/gml/3.2}AbstractGeometryType
    
    # Attribute id inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Attribute aggregationType inherited from {http://www.opengis.net/gml/3.2}AbstractGeometricAggregateType
    _ElementMap.update({
        __surfaceMembers.name() : __surfaceMembers,
        __surfaceMember.name() : __surfaceMember
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.MultiSurfaceType = MultiSurfaceType
_Namespace_gml.addCategoryObject('typeBinding', 'MultiSurfaceType', MultiSurfaceType)


# Complex type {http://www.opengis.net/gml/3.2}MultiSolidType with content type ELEMENT_ONLY
class MultiSolidType (AbstractGeometricAggregateType):
    """Complex type {http://www.opengis.net/gml/3.2}MultiSolidType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'MultiSolidType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryAggregates.xsd', 161, 1)
    _ElementMap = AbstractGeometricAggregateType._ElementMap.copy()
    _AttributeMap = AbstractGeometricAggregateType._AttributeMap.copy()
    # Base type is AbstractGeometricAggregateType
    
    # Element metaDataProperty ({http://www.opengis.net/gml/3.2}metaDataProperty) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element {http://www.opengis.net/gml/3.2}solidMember uses Python identifier solidMember
    __solidMember = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'solidMember'), 'solidMember', '__httpwww_opengis_netgml3_2_MultiSolidType_httpwww_opengis_netgml3_2solidMember', True, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryAggregates.xsd', 177, 1), )

    
    solidMember = property(__solidMember.value, __solidMember.set, None, 'This property element either references a solid via the XLink-attributes or contains the solid element. A solid element is any element, which is substitutable for gml:AbstractSolid.')

    
    # Element {http://www.opengis.net/gml/3.2}solidMembers uses Python identifier solidMembers
    __solidMembers = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'solidMembers'), 'solidMembers', '__httpwww_opengis_netgml3_2_MultiSolidType_httpwww_opengis_netgml3_2solidMembers', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryAggregates.xsd', 182, 1), )

    
    solidMembers = property(__solidMembers.value, __solidMembers.set, None, 'This property element contains a list of solids. The order of the elements is significant and shall be preserved when processing the array.')

    
    # Element description ({http://www.opengis.net/gml/3.2}description) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element descriptionReference ({http://www.opengis.net/gml/3.2}descriptionReference) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element name ({http://www.opengis.net/gml/3.2}name) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element identifier ({http://www.opengis.net/gml/3.2}identifier) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Attribute srsName inherited from {http://www.opengis.net/gml/3.2}AbstractGeometryType
    
    # Attribute srsDimension inherited from {http://www.opengis.net/gml/3.2}AbstractGeometryType
    
    # Attribute axisLabels inherited from {http://www.opengis.net/gml/3.2}AbstractGeometryType
    
    # Attribute uomLabels inherited from {http://www.opengis.net/gml/3.2}AbstractGeometryType
    
    # Attribute id inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Attribute aggregationType inherited from {http://www.opengis.net/gml/3.2}AbstractGeometricAggregateType
    _ElementMap.update({
        __solidMember.name() : __solidMember,
        __solidMembers.name() : __solidMembers
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.MultiSolidType = MultiSolidType
_Namespace_gml.addCategoryObject('typeBinding', 'MultiSolidType', MultiSolidType)


# Complex type {http://www.opengis.net/gml/3.2}PointType with content type ELEMENT_ONLY
class PointType (AbstractGeometricPrimitiveType):
    """Complex type {http://www.opengis.net/gml/3.2}PointType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'PointType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic0d1d.xsd', 177, 1)
    _ElementMap = AbstractGeometricPrimitiveType._ElementMap.copy()
    _AttributeMap = AbstractGeometricPrimitiveType._AttributeMap.copy()
    # Base type is AbstractGeometricPrimitiveType
    
    # Element metaDataProperty ({http://www.opengis.net/gml/3.2}metaDataProperty) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element {http://www.opengis.net/gml/3.2}coordinates uses Python identifier coordinates
    __coordinates = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'coordinates'), 'coordinates', '__httpwww_opengis_netgml3_2_PointType_httpwww_opengis_netgml3_2coordinates', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 751, 1), )

    
    coordinates = property(__coordinates.value, __coordinates.set, None, '')

    
    # Element {http://www.opengis.net/gml/3.2}pos uses Python identifier pos
    __pos = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'pos'), 'pos', '__httpwww_opengis_netgml3_2_PointType_httpwww_opengis_netgml3_2pos', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic0d1d.xsd', 87, 1), )

    
    pos = property(__pos.value, __pos.set, None, None)

    
    # Element description ({http://www.opengis.net/gml/3.2}description) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element descriptionReference ({http://www.opengis.net/gml/3.2}descriptionReference) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element name ({http://www.opengis.net/gml/3.2}name) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element identifier ({http://www.opengis.net/gml/3.2}identifier) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Attribute srsName inherited from {http://www.opengis.net/gml/3.2}AbstractGeometryType
    
    # Attribute srsDimension inherited from {http://www.opengis.net/gml/3.2}AbstractGeometryType
    
    # Attribute axisLabels inherited from {http://www.opengis.net/gml/3.2}AbstractGeometryType
    
    # Attribute uomLabels inherited from {http://www.opengis.net/gml/3.2}AbstractGeometryType
    
    # Attribute id inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    _ElementMap.update({
        __coordinates.name() : __coordinates,
        __pos.name() : __pos
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.PointType = PointType
_Namespace_gml.addCategoryObject('typeBinding', 'PointType', PointType)


# Complex type {http://www.opengis.net/gml/3.2}AbstractCurveType with content type ELEMENT_ONLY
class AbstractCurveType (AbstractGeometricPrimitiveType):
    """gml:AbstractCurveType is an abstraction of a curve to support the different levels of complexity. The curve may always be viewed as a geometric primitive, i.e. is continuous."""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = True
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractCurveType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic0d1d.xsd', 218, 1)
    _ElementMap = AbstractGeometricPrimitiveType._ElementMap.copy()
    _AttributeMap = AbstractGeometricPrimitiveType._AttributeMap.copy()
    # Base type is AbstractGeometricPrimitiveType
    
    # Element metaDataProperty ({http://www.opengis.net/gml/3.2}metaDataProperty) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element description ({http://www.opengis.net/gml/3.2}description) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element descriptionReference ({http://www.opengis.net/gml/3.2}descriptionReference) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element name ({http://www.opengis.net/gml/3.2}name) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element identifier ({http://www.opengis.net/gml/3.2}identifier) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Attribute srsName inherited from {http://www.opengis.net/gml/3.2}AbstractGeometryType
    
    # Attribute srsDimension inherited from {http://www.opengis.net/gml/3.2}AbstractGeometryType
    
    # Attribute axisLabels inherited from {http://www.opengis.net/gml/3.2}AbstractGeometryType
    
    # Attribute uomLabels inherited from {http://www.opengis.net/gml/3.2}AbstractGeometryType
    
    # Attribute id inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    _ElementMap.update({
        
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.AbstractCurveType = AbstractCurveType
_Namespace_gml.addCategoryObject('typeBinding', 'AbstractCurveType', AbstractCurveType)


# Complex type {http://www.opengis.net/gml/3.2}AbstractSurfaceType with content type ELEMENT_ONLY
class AbstractSurfaceType (AbstractGeometricPrimitiveType):
    """gml:AbstractSurfaceType is an abstraction of a surface to support the different levels of complexity. A surface is always a continuous region of a plane."""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = True
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractSurfaceType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic2d.xsd', 14, 1)
    _ElementMap = AbstractGeometricPrimitiveType._ElementMap.copy()
    _AttributeMap = AbstractGeometricPrimitiveType._AttributeMap.copy()
    # Base type is AbstractGeometricPrimitiveType
    
    # Element metaDataProperty ({http://www.opengis.net/gml/3.2}metaDataProperty) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element description ({http://www.opengis.net/gml/3.2}description) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element descriptionReference ({http://www.opengis.net/gml/3.2}descriptionReference) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element name ({http://www.opengis.net/gml/3.2}name) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element identifier ({http://www.opengis.net/gml/3.2}identifier) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Attribute srsName inherited from {http://www.opengis.net/gml/3.2}AbstractGeometryType
    
    # Attribute srsDimension inherited from {http://www.opengis.net/gml/3.2}AbstractGeometryType
    
    # Attribute axisLabels inherited from {http://www.opengis.net/gml/3.2}AbstractGeometryType
    
    # Attribute uomLabels inherited from {http://www.opengis.net/gml/3.2}AbstractGeometryType
    
    # Attribute id inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    _ElementMap.update({
        
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.AbstractSurfaceType = AbstractSurfaceType
_Namespace_gml.addCategoryObject('typeBinding', 'AbstractSurfaceType', AbstractSurfaceType)


# Complex type {http://www.opengis.net/gml/3.2}CircleType with content type ELEMENT_ONLY
class CircleType (ArcType):
    """Complex type {http://www.opengis.net/gml/3.2}CircleType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'CircleType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 168, 1)
    _ElementMap = ArcType._ElementMap.copy()
    _AttributeMap = ArcType._AttributeMap.copy()
    # Base type is ArcType
    
    # Element coordinates ({http://www.opengis.net/gml/3.2}coordinates) inherited from {http://www.opengis.net/gml/3.2}ArcStringType
    
    # Element pointRep ({http://www.opengis.net/gml/3.2}pointRep) inherited from {http://www.opengis.net/gml/3.2}ArcStringType
    
    # Element pos ({http://www.opengis.net/gml/3.2}pos) inherited from {http://www.opengis.net/gml/3.2}ArcStringType
    
    # Element posList ({http://www.opengis.net/gml/3.2}posList) inherited from {http://www.opengis.net/gml/3.2}ArcStringType
    
    # Element pointProperty ({http://www.opengis.net/gml/3.2}pointProperty) inherited from {http://www.opengis.net/gml/3.2}ArcStringType
    
    # Attribute numDerivativesAtStart inherited from {http://www.opengis.net/gml/3.2}AbstractCurveSegmentType
    
    # Attribute numDerivativesAtEnd inherited from {http://www.opengis.net/gml/3.2}AbstractCurveSegmentType
    
    # Attribute numDerivativeInterior inherited from {http://www.opengis.net/gml/3.2}AbstractCurveSegmentType
    
    # Attribute interpolation inherited from {http://www.opengis.net/gml/3.2}ArcStringType
    
    # Attribute numArc_ inherited from {http://www.opengis.net/gml/3.2}ArcType
    _ElementMap.update({
        
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.CircleType = CircleType
_Namespace_gml.addCategoryObject('typeBinding', 'CircleType', CircleType)


# Complex type {http://www.opengis.net/gml/3.2}ConeType with content type ELEMENT_ONLY
class ConeType (AbstractGriddedSurfaceType):
    """Complex type {http://www.opengis.net/gml/3.2}ConeType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'ConeType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 696, 1)
    _ElementMap = AbstractGriddedSurfaceType._ElementMap.copy()
    _AttributeMap = AbstractGriddedSurfaceType._AttributeMap.copy()
    # Base type is AbstractGriddedSurfaceType
    
    # Element rows ({http://www.opengis.net/gml/3.2}rows) inherited from {http://www.opengis.net/gml/3.2}AbstractGriddedSurfaceType
    
    # Attribute rows_ inherited from {http://www.opengis.net/gml/3.2}AbstractGriddedSurfaceType
    
    # Attribute columns inherited from {http://www.opengis.net/gml/3.2}AbstractGriddedSurfaceType
    
    # Attribute horizontalCurveType uses Python identifier horizontalCurveType
    __horizontalCurveType = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'horizontalCurveType'), 'horizontalCurveType', '__httpwww_opengis_netgml3_2_ConeType_horizontalCurveType', _module_typeBindings.CurveInterpolationType, fixed=True, unicode_default='circularArc3Points')
    __horizontalCurveType._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 699, 4)
    __horizontalCurveType._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 699, 4)
    
    horizontalCurveType = property(__horizontalCurveType.value, __horizontalCurveType.set, None, None)

    
    # Attribute verticalCurveType uses Python identifier verticalCurveType
    __verticalCurveType = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'verticalCurveType'), 'verticalCurveType', '__httpwww_opengis_netgml3_2_ConeType_verticalCurveType', _module_typeBindings.CurveInterpolationType, fixed=True, unicode_default='linear')
    __verticalCurveType._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 700, 4)
    __verticalCurveType._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 700, 4)
    
    verticalCurveType = property(__verticalCurveType.value, __verticalCurveType.set, None, None)

    
    # Attribute aggregationType inherited from {http://www.opengis.net/gml/3.2}AbstractParametricCurveSurfaceType
    _ElementMap.update({
        
    })
    _AttributeMap.update({
        __horizontalCurveType.name() : __horizontalCurveType,
        __verticalCurveType.name() : __verticalCurveType
    })
_module_typeBindings.ConeType = ConeType
_Namespace_gml.addCategoryObject('typeBinding', 'ConeType', ConeType)


# Complex type {http://www.opengis.net/gml/3.2}CylinderType with content type ELEMENT_ONLY
class CylinderType (AbstractGriddedSurfaceType):
    """Complex type {http://www.opengis.net/gml/3.2}CylinderType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'CylinderType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 705, 1)
    _ElementMap = AbstractGriddedSurfaceType._ElementMap.copy()
    _AttributeMap = AbstractGriddedSurfaceType._AttributeMap.copy()
    # Base type is AbstractGriddedSurfaceType
    
    # Element rows ({http://www.opengis.net/gml/3.2}rows) inherited from {http://www.opengis.net/gml/3.2}AbstractGriddedSurfaceType
    
    # Attribute rows_ inherited from {http://www.opengis.net/gml/3.2}AbstractGriddedSurfaceType
    
    # Attribute columns inherited from {http://www.opengis.net/gml/3.2}AbstractGriddedSurfaceType
    
    # Attribute horizontalCurveType uses Python identifier horizontalCurveType
    __horizontalCurveType = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'horizontalCurveType'), 'horizontalCurveType', '__httpwww_opengis_netgml3_2_CylinderType_horizontalCurveType', _module_typeBindings.CurveInterpolationType, fixed=True, unicode_default='circularArc3Points')
    __horizontalCurveType._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 708, 4)
    __horizontalCurveType._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 708, 4)
    
    horizontalCurveType = property(__horizontalCurveType.value, __horizontalCurveType.set, None, None)

    
    # Attribute verticalCurveType uses Python identifier verticalCurveType
    __verticalCurveType = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'verticalCurveType'), 'verticalCurveType', '__httpwww_opengis_netgml3_2_CylinderType_verticalCurveType', _module_typeBindings.CurveInterpolationType, fixed=True, unicode_default='linear')
    __verticalCurveType._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 709, 4)
    __verticalCurveType._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 709, 4)
    
    verticalCurveType = property(__verticalCurveType.value, __verticalCurveType.set, None, None)

    
    # Attribute aggregationType inherited from {http://www.opengis.net/gml/3.2}AbstractParametricCurveSurfaceType
    _ElementMap.update({
        
    })
    _AttributeMap.update({
        __horizontalCurveType.name() : __horizontalCurveType,
        __verticalCurveType.name() : __verticalCurveType
    })
_module_typeBindings.CylinderType = CylinderType
_Namespace_gml.addCategoryObject('typeBinding', 'CylinderType', CylinderType)


# Complex type {http://www.opengis.net/gml/3.2}SphereType with content type ELEMENT_ONLY
class SphereType (AbstractGriddedSurfaceType):
    """Complex type {http://www.opengis.net/gml/3.2}SphereType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'SphereType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 714, 1)
    _ElementMap = AbstractGriddedSurfaceType._ElementMap.copy()
    _AttributeMap = AbstractGriddedSurfaceType._AttributeMap.copy()
    # Base type is AbstractGriddedSurfaceType
    
    # Element rows ({http://www.opengis.net/gml/3.2}rows) inherited from {http://www.opengis.net/gml/3.2}AbstractGriddedSurfaceType
    
    # Attribute rows_ inherited from {http://www.opengis.net/gml/3.2}AbstractGriddedSurfaceType
    
    # Attribute columns inherited from {http://www.opengis.net/gml/3.2}AbstractGriddedSurfaceType
    
    # Attribute horizontalCurveType uses Python identifier horizontalCurveType
    __horizontalCurveType = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'horizontalCurveType'), 'horizontalCurveType', '__httpwww_opengis_netgml3_2_SphereType_horizontalCurveType', _module_typeBindings.CurveInterpolationType, fixed=True, unicode_default='circularArc3Points')
    __horizontalCurveType._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 717, 4)
    __horizontalCurveType._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 717, 4)
    
    horizontalCurveType = property(__horizontalCurveType.value, __horizontalCurveType.set, None, None)

    
    # Attribute verticalCurveType uses Python identifier verticalCurveType
    __verticalCurveType = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'verticalCurveType'), 'verticalCurveType', '__httpwww_opengis_netgml3_2_SphereType_verticalCurveType', _module_typeBindings.CurveInterpolationType, fixed=True, unicode_default='circularArc3Points')
    __verticalCurveType._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 718, 4)
    __verticalCurveType._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 718, 4)
    
    verticalCurveType = property(__verticalCurveType.value, __verticalCurveType.set, None, None)

    
    # Attribute aggregationType inherited from {http://www.opengis.net/gml/3.2}AbstractParametricCurveSurfaceType
    _ElementMap.update({
        
    })
    _AttributeMap.update({
        __horizontalCurveType.name() : __horizontalCurveType,
        __verticalCurveType.name() : __verticalCurveType
    })
_module_typeBindings.SphereType = SphereType
_Namespace_gml.addCategoryObject('typeBinding', 'SphereType', SphereType)


# Complex type {http://www.opengis.net/gml/3.2}AbstractSolidType with content type ELEMENT_ONLY
class AbstractSolidType (AbstractGeometricPrimitiveType):
    """gml:AbstractSolidType is an abstraction of a solid to support the different levels of complexity. The solid may always be viewed as a geometric primitive, i.e. is contiguous."""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractSolidType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 767, 1)
    _ElementMap = AbstractGeometricPrimitiveType._ElementMap.copy()
    _AttributeMap = AbstractGeometricPrimitiveType._AttributeMap.copy()
    # Base type is AbstractGeometricPrimitiveType
    
    # Element metaDataProperty ({http://www.opengis.net/gml/3.2}metaDataProperty) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element description ({http://www.opengis.net/gml/3.2}description) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element descriptionReference ({http://www.opengis.net/gml/3.2}descriptionReference) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element name ({http://www.opengis.net/gml/3.2}name) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element identifier ({http://www.opengis.net/gml/3.2}identifier) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Attribute srsName inherited from {http://www.opengis.net/gml/3.2}AbstractGeometryType
    
    # Attribute srsDimension inherited from {http://www.opengis.net/gml/3.2}AbstractGeometryType
    
    # Attribute axisLabels inherited from {http://www.opengis.net/gml/3.2}AbstractGeometryType
    
    # Attribute uomLabels inherited from {http://www.opengis.net/gml/3.2}AbstractGeometryType
    
    # Attribute id inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    _ElementMap.update({
        
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.AbstractSolidType = AbstractSolidType
_Namespace_gml.addCategoryObject('typeBinding', 'AbstractSolidType', AbstractSolidType)


# Complex type {http://www.opengis.net/gml/3.2}RectifiedGridType with content type ELEMENT_ONLY
class RectifiedGridType (GridType):
    """Complex type {http://www.opengis.net/gml/3.2}RectifiedGridType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'RectifiedGridType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/grids.xsd', 54, 1)
    _ElementMap = GridType._ElementMap.copy()
    _AttributeMap = GridType._AttributeMap.copy()
    # Base type is GridType
    
    # Element metaDataProperty ({http://www.opengis.net/gml/3.2}metaDataProperty) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element description ({http://www.opengis.net/gml/3.2}description) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element descriptionReference ({http://www.opengis.net/gml/3.2}descriptionReference) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element name ({http://www.opengis.net/gml/3.2}name) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element identifier ({http://www.opengis.net/gml/3.2}identifier) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element limits ({http://www.opengis.net/gml/3.2}limits) inherited from {http://www.opengis.net/gml/3.2}GridType
    
    # Element axisLabels_ ({http://www.opengis.net/gml/3.2}axisLabels) inherited from {http://www.opengis.net/gml/3.2}GridType
    
    # Element axisName ({http://www.opengis.net/gml/3.2}axisName) inherited from {http://www.opengis.net/gml/3.2}GridType
    
    # Element {http://www.opengis.net/gml/3.2}origin uses Python identifier origin
    __origin = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'origin'), 'origin', '__httpwww_opengis_netgml3_2_RectifiedGridType_httpwww_opengis_netgml3_2origin', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/grids.xsd', 58, 5), )

    
    origin = property(__origin.value, __origin.set, None, None)

    
    # Element {http://www.opengis.net/gml/3.2}offsetVector uses Python identifier offsetVector
    __offsetVector = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'offsetVector'), 'offsetVector', '__httpwww_opengis_netgml3_2_RectifiedGridType_httpwww_opengis_netgml3_2offsetVector', True, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/grids.xsd', 59, 5), )

    
    offsetVector = property(__offsetVector.value, __offsetVector.set, None, None)

    
    # Attribute srsName inherited from {http://www.opengis.net/gml/3.2}AbstractGeometryType
    
    # Attribute srsDimension inherited from {http://www.opengis.net/gml/3.2}AbstractGeometryType
    
    # Attribute axisLabels inherited from {http://www.opengis.net/gml/3.2}AbstractGeometryType
    
    # Attribute uomLabels inherited from {http://www.opengis.net/gml/3.2}AbstractGeometryType
    
    # Attribute id inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Attribute dimension inherited from {http://www.opengis.net/gml/3.2}GridType
    _ElementMap.update({
        __origin.name() : __origin,
        __offsetVector.name() : __offsetVector
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.RectifiedGridType = RectifiedGridType
_Namespace_gml.addCategoryObject('typeBinding', 'RectifiedGridType', RectifiedGridType)


# Complex type {http://www.opengis.net/gml/3.2}LengthType with content type SIMPLE
class LengthType (MeasureType):
    """This is a prototypical definition for a specific measure type defined as a vacuous extension (i.e. aliases) of gml:MeasureType. In this case, the content model supports the description of a length (or distance) quantity, with its units. The unit of measure referenced by uom shall be suitable for a length, such as metres or feet."""
    _TypeDefinition = pyxb.binding.datatypes.double
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_SIMPLE
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'LengthType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/measures.xsd', 20, 1)
    _ElementMap = MeasureType._ElementMap.copy()
    _AttributeMap = MeasureType._AttributeMap.copy()
    # Base type is MeasureType
    
    # Attribute uom inherited from {http://www.opengis.net/gml/3.2}MeasureType
    _ElementMap.update({
        
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.LengthType = LengthType
_Namespace_gml.addCategoryObject('typeBinding', 'LengthType', LengthType)


# Complex type {http://www.opengis.net/gml/3.2}ScaleType with content type SIMPLE
class ScaleType (MeasureType):
    """Complex type {http://www.opengis.net/gml/3.2}ScaleType with content type SIMPLE"""
    _TypeDefinition = pyxb.binding.datatypes.double
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_SIMPLE
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'ScaleType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/measures.xsd', 28, 1)
    _ElementMap = MeasureType._ElementMap.copy()
    _AttributeMap = MeasureType._AttributeMap.copy()
    # Base type is MeasureType
    
    # Attribute uom inherited from {http://www.opengis.net/gml/3.2}MeasureType
    _ElementMap.update({
        
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.ScaleType = ScaleType
_Namespace_gml.addCategoryObject('typeBinding', 'ScaleType', ScaleType)


# Complex type {http://www.opengis.net/gml/3.2}TimeType with content type SIMPLE
class TimeType (MeasureType):
    """Complex type {http://www.opengis.net/gml/3.2}TimeType with content type SIMPLE"""
    _TypeDefinition = pyxb.binding.datatypes.double
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_SIMPLE
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'TimeType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/measures.xsd', 33, 1)
    _ElementMap = MeasureType._ElementMap.copy()
    _AttributeMap = MeasureType._AttributeMap.copy()
    # Base type is MeasureType
    
    # Attribute uom inherited from {http://www.opengis.net/gml/3.2}MeasureType
    _ElementMap.update({
        
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.TimeType = TimeType
_Namespace_gml.addCategoryObject('typeBinding', 'TimeType', TimeType)


# Complex type {http://www.opengis.net/gml/3.2}GridLengthType with content type SIMPLE
class GridLengthType (MeasureType):
    """Complex type {http://www.opengis.net/gml/3.2}GridLengthType with content type SIMPLE"""
    _TypeDefinition = pyxb.binding.datatypes.double
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_SIMPLE
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'GridLengthType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/measures.xsd', 38, 1)
    _ElementMap = MeasureType._ElementMap.copy()
    _AttributeMap = MeasureType._AttributeMap.copy()
    # Base type is MeasureType
    
    # Attribute uom inherited from {http://www.opengis.net/gml/3.2}MeasureType
    _ElementMap.update({
        
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.GridLengthType = GridLengthType
_Namespace_gml.addCategoryObject('typeBinding', 'GridLengthType', GridLengthType)


# Complex type {http://www.opengis.net/gml/3.2}AreaType with content type SIMPLE
class AreaType (MeasureType):
    """Complex type {http://www.opengis.net/gml/3.2}AreaType with content type SIMPLE"""
    _TypeDefinition = pyxb.binding.datatypes.double
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_SIMPLE
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'AreaType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/measures.xsd', 43, 1)
    _ElementMap = MeasureType._ElementMap.copy()
    _AttributeMap = MeasureType._AttributeMap.copy()
    # Base type is MeasureType
    
    # Attribute uom inherited from {http://www.opengis.net/gml/3.2}MeasureType
    _ElementMap.update({
        
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.AreaType = AreaType
_Namespace_gml.addCategoryObject('typeBinding', 'AreaType', AreaType)


# Complex type {http://www.opengis.net/gml/3.2}VolumeType with content type SIMPLE
class VolumeType (MeasureType):
    """Complex type {http://www.opengis.net/gml/3.2}VolumeType with content type SIMPLE"""
    _TypeDefinition = pyxb.binding.datatypes.double
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_SIMPLE
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'VolumeType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/measures.xsd', 48, 1)
    _ElementMap = MeasureType._ElementMap.copy()
    _AttributeMap = MeasureType._AttributeMap.copy()
    # Base type is MeasureType
    
    # Attribute uom inherited from {http://www.opengis.net/gml/3.2}MeasureType
    _ElementMap.update({
        
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.VolumeType = VolumeType
_Namespace_gml.addCategoryObject('typeBinding', 'VolumeType', VolumeType)


# Complex type {http://www.opengis.net/gml/3.2}SpeedType with content type SIMPLE
class SpeedType (MeasureType):
    """Complex type {http://www.opengis.net/gml/3.2}SpeedType with content type SIMPLE"""
    _TypeDefinition = pyxb.binding.datatypes.double
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_SIMPLE
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'SpeedType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/measures.xsd', 53, 1)
    _ElementMap = MeasureType._ElementMap.copy()
    _AttributeMap = MeasureType._AttributeMap.copy()
    # Base type is MeasureType
    
    # Attribute uom inherited from {http://www.opengis.net/gml/3.2}MeasureType
    _ElementMap.update({
        
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.SpeedType = SpeedType
_Namespace_gml.addCategoryObject('typeBinding', 'SpeedType', SpeedType)


# Complex type {http://www.opengis.net/gml/3.2}AngleType with content type SIMPLE
class AngleType (MeasureType):
    """Complex type {http://www.opengis.net/gml/3.2}AngleType with content type SIMPLE"""
    _TypeDefinition = pyxb.binding.datatypes.double
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_SIMPLE
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'AngleType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/measures.xsd', 58, 1)
    _ElementMap = MeasureType._ElementMap.copy()
    _AttributeMap = MeasureType._AttributeMap.copy()
    # Base type is MeasureType
    
    # Attribute uom inherited from {http://www.opengis.net/gml/3.2}MeasureType
    _ElementMap.update({
        
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.AngleType = AngleType
_Namespace_gml.addCategoryObject('typeBinding', 'AngleType', AngleType)


# Complex type {http://www.opengis.net/gml/3.2}DirectedObservationType with content type ELEMENT_ONLY
class DirectedObservationType (ObservationType):
    """Complex type {http://www.opengis.net/gml/3.2}DirectedObservationType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'DirectedObservationType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/observation.xsd', 72, 1)
    _ElementMap = ObservationType._ElementMap.copy()
    _AttributeMap = ObservationType._AttributeMap.copy()
    # Base type is ObservationType
    
    # Element metaDataProperty ({http://www.opengis.net/gml/3.2}metaDataProperty) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element location ({http://www.opengis.net/gml/3.2}location) inherited from {http://www.opengis.net/gml/3.2}AbstractFeatureType
    
    # Element {http://www.opengis.net/gml/3.2}direction uses Python identifier direction
    __direction = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'direction'), 'direction', '__httpwww_opengis_netgml3_2_DirectedObservationType_httpwww_opengis_netgml3_2direction', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/direction.xsd', 15, 1), )

    
    direction = property(__direction.value, __direction.set, None, 'The property gml:direction is intended as a pre-defined property expressing a direction to be assigned to features defined in a GML application schema.')

    
    # Element boundedBy ({http://www.opengis.net/gml/3.2}boundedBy) inherited from {http://www.opengis.net/gml/3.2}AbstractFeatureType
    
    # Element description ({http://www.opengis.net/gml/3.2}description) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element descriptionReference ({http://www.opengis.net/gml/3.2}descriptionReference) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element name ({http://www.opengis.net/gml/3.2}name) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element identifier ({http://www.opengis.net/gml/3.2}identifier) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element using ({http://www.opengis.net/gml/3.2}using) inherited from {http://www.opengis.net/gml/3.2}ObservationType
    
    # Element target ({http://www.opengis.net/gml/3.2}target) inherited from {http://www.opengis.net/gml/3.2}ObservationType
    
    # Element resultOf ({http://www.opengis.net/gml/3.2}resultOf) inherited from {http://www.opengis.net/gml/3.2}ObservationType
    
    # Element validTime ({http://www.opengis.net/gml/3.2}validTime) inherited from {http://www.opengis.net/gml/3.2}ObservationType
    
    # Attribute id inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    _ElementMap.update({
        __direction.name() : __direction
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.DirectedObservationType = DirectedObservationType
_Namespace_gml.addCategoryObject('typeBinding', 'DirectedObservationType', DirectedObservationType)


# Complex type {http://www.opengis.net/gml/3.2}IdentifiedObjectType with content type ELEMENT_ONLY
class IdentifiedObjectType (DefinitionType):
    """gml:IdentifiedObjectType provides identification properties of a CRS-related object. In gml:DefinitionType, the gml:identifier element shall be the primary name by which this object is identified, encoding the "name" attribute in the UML model.
Zero or more of the gml:name elements can be an unordered set of "identifiers", encoding the "identifier" attribute in the UML model. Each of these gml:name elements can reference elsewhere the object's defining information or be an identifier by which this object can be referenced.
Zero or more other gml:name elements can be an unordered set of "alias" alternative names by which this CRS related object is identified, encoding the "alias" attributes in the UML model. An object may have several aliases, typically used in different contexts. The context for an alias is indicated by the value of its (optional) codeSpace attribute.
Any needed version information shall be included in the codeSpace attribute of a gml:identifier and gml:name elements. In this use, the gml:remarks element in the gml:DefinitionType shall contain comments on or information about this object, including data source information."""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = True
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'IdentifiedObjectType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/referenceSystems.xsd', 19, 1)
    _ElementMap = DefinitionType._ElementMap.copy()
    _AttributeMap = DefinitionType._AttributeMap.copy()
    # Base type is DefinitionType
    
    # Element metaDataProperty ({http://www.opengis.net/gml/3.2}metaDataProperty) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element remarks ({http://www.opengis.net/gml/3.2}remarks) inherited from {http://www.opengis.net/gml/3.2}DefinitionType
    
    # Element description ({http://www.opengis.net/gml/3.2}description) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element descriptionReference ({http://www.opengis.net/gml/3.2}descriptionReference) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element name ({http://www.opengis.net/gml/3.2}name) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element identifier ({http://www.opengis.net/gml/3.2}identifier) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Attribute id_ inherited from {http://www.opengis.net/gml/3.2}DefinitionBaseType
    _ElementMap.update({
        
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.IdentifiedObjectType = IdentifiedObjectType
_Namespace_gml.addCategoryObject('typeBinding', 'IdentifiedObjectType', IdentifiedObjectType)


# Complex type {http://www.opengis.net/gml/3.2}RelatedTimeType with content type ELEMENT_ONLY
class RelatedTimeType (TimePrimitivePropertyType):
    """gml:RelatedTimeType provides a content model for indicating the relative position of an arbitrary member of the substitution group whose head is gml:AbstractTimePrimitive. It extends the generic gml:TimePrimitivePropertyType with an XML attribute relativePosition, whose value is selected from the set of 13 temporal relationships identified by Allen (1983)"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'RelatedTimeType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporal.xsd', 57, 1)
    _ElementMap = TimePrimitivePropertyType._ElementMap.copy()
    _AttributeMap = TimePrimitivePropertyType._AttributeMap.copy()
    # Base type is TimePrimitivePropertyType
    
    # Element AbstractTimePrimitive ({http://www.opengis.net/gml/3.2}AbstractTimePrimitive) inherited from {http://www.opengis.net/gml/3.2}TimePrimitivePropertyType
    
    # Attribute remoteSchema inherited from {http://www.opengis.net/gml/3.2}TimePrimitivePropertyType
    
    # Attribute nilReason inherited from {http://www.opengis.net/gml/3.2}TimePrimitivePropertyType
    
    # Attribute owns inherited from {http://www.opengis.net/gml/3.2}TimePrimitivePropertyType
    
    # Attribute relativePosition uses Python identifier relativePosition
    __relativePosition = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'relativePosition'), 'relativePosition', '__httpwww_opengis_netgml3_2_RelatedTimeType_relativePosition', _module_typeBindings.STD_ANON_4)
    __relativePosition._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporal.xsd', 63, 4)
    __relativePosition._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporal.xsd', 63, 4)
    
    relativePosition = property(__relativePosition.value, __relativePosition.set, None, None)

    
    # Attribute type inherited from {http://www.opengis.net/gml/3.2}TimePrimitivePropertyType
    
    # Attribute href inherited from {http://www.opengis.net/gml/3.2}TimePrimitivePropertyType
    
    # Attribute role inherited from {http://www.opengis.net/gml/3.2}TimePrimitivePropertyType
    
    # Attribute arcrole inherited from {http://www.opengis.net/gml/3.2}TimePrimitivePropertyType
    
    # Attribute title inherited from {http://www.opengis.net/gml/3.2}TimePrimitivePropertyType
    
    # Attribute show inherited from {http://www.opengis.net/gml/3.2}TimePrimitivePropertyType
    
    # Attribute actuate inherited from {http://www.opengis.net/gml/3.2}TimePrimitivePropertyType
    _ElementMap.update({
        
    })
    _AttributeMap.update({
        __relativePosition.name() : __relativePosition
    })
_module_typeBindings.RelatedTimeType = RelatedTimeType
_Namespace_gml.addCategoryObject('typeBinding', 'RelatedTimeType', RelatedTimeType)


# Complex type {http://www.opengis.net/gml/3.2}AbstractTimeGeometricPrimitiveType with content type ELEMENT_ONLY
class AbstractTimeGeometricPrimitiveType (AbstractTimePrimitiveType):
    """Complex type {http://www.opengis.net/gml/3.2}AbstractTimeGeometricPrimitiveType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = True
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractTimeGeometricPrimitiveType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporal.xsd', 102, 1)
    _ElementMap = AbstractTimePrimitiveType._ElementMap.copy()
    _AttributeMap = AbstractTimePrimitiveType._AttributeMap.copy()
    # Base type is AbstractTimePrimitiveType
    
    # Element metaDataProperty ({http://www.opengis.net/gml/3.2}metaDataProperty) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element description ({http://www.opengis.net/gml/3.2}description) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element descriptionReference ({http://www.opengis.net/gml/3.2}descriptionReference) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element name ({http://www.opengis.net/gml/3.2}name) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element identifier ({http://www.opengis.net/gml/3.2}identifier) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element relatedTime ({http://www.opengis.net/gml/3.2}relatedTime) inherited from {http://www.opengis.net/gml/3.2}AbstractTimePrimitiveType
    
    # Attribute id inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Attribute frame uses Python identifier frame
    __frame = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'frame'), 'frame', '__httpwww_opengis_netgml3_2_AbstractTimeGeometricPrimitiveType_frame', pyxb.binding.datatypes.anyURI, unicode_default='#ISO-8601')
    __frame._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporal.xsd', 105, 4)
    __frame._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporal.xsd', 105, 4)
    
    frame = property(__frame.value, __frame.set, None, None)

    _ElementMap.update({
        
    })
    _AttributeMap.update({
        __frame.name() : __frame
    })
_module_typeBindings.AbstractTimeGeometricPrimitiveType = AbstractTimeGeometricPrimitiveType
_Namespace_gml.addCategoryObject('typeBinding', 'AbstractTimeGeometricPrimitiveType', AbstractTimeGeometricPrimitiveType)


# Complex type {http://www.opengis.net/gml/3.2}TimeReferenceSystemType with content type ELEMENT_ONLY
class TimeReferenceSystemType (DefinitionType):
    """Complex type {http://www.opengis.net/gml/3.2}TimeReferenceSystemType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'TimeReferenceSystemType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporalReferenceSystems.xsd', 22, 1)
    _ElementMap = DefinitionType._ElementMap.copy()
    _AttributeMap = DefinitionType._AttributeMap.copy()
    # Base type is DefinitionType
    
    # Element metaDataProperty ({http://www.opengis.net/gml/3.2}metaDataProperty) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element remarks ({http://www.opengis.net/gml/3.2}remarks) inherited from {http://www.opengis.net/gml/3.2}DefinitionType
    
    # Element description ({http://www.opengis.net/gml/3.2}description) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element descriptionReference ({http://www.opengis.net/gml/3.2}descriptionReference) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element name ({http://www.opengis.net/gml/3.2}name) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element identifier ({http://www.opengis.net/gml/3.2}identifier) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element {http://www.opengis.net/gml/3.2}domainOfValidity uses Python identifier domainOfValidity
    __domainOfValidity = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'domainOfValidity'), 'domainOfValidity', '__httpwww_opengis_netgml3_2_TimeReferenceSystemType_httpwww_opengis_netgml3_2domainOfValidity', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporalReferenceSystems.xsd', 26, 5), )

    
    domainOfValidity = property(__domainOfValidity.value, __domainOfValidity.set, None, None)

    
    # Attribute id_ inherited from {http://www.opengis.net/gml/3.2}DefinitionBaseType
    _ElementMap.update({
        __domainOfValidity.name() : __domainOfValidity
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.TimeReferenceSystemType = TimeReferenceSystemType
_Namespace_gml.addCategoryObject('typeBinding', 'TimeReferenceSystemType', TimeReferenceSystemType)


# Complex type {http://www.opengis.net/gml/3.2}TimeCalendarEraType with content type ELEMENT_ONLY
class TimeCalendarEraType (DefinitionType):
    """Complex type {http://www.opengis.net/gml/3.2}TimeCalendarEraType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'TimeCalendarEraType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporalReferenceSystems.xsd', 78, 1)
    _ElementMap = DefinitionType._ElementMap.copy()
    _AttributeMap = DefinitionType._AttributeMap.copy()
    # Base type is DefinitionType
    
    # Element metaDataProperty ({http://www.opengis.net/gml/3.2}metaDataProperty) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element remarks ({http://www.opengis.net/gml/3.2}remarks) inherited from {http://www.opengis.net/gml/3.2}DefinitionType
    
    # Element description ({http://www.opengis.net/gml/3.2}description) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element descriptionReference ({http://www.opengis.net/gml/3.2}descriptionReference) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element name ({http://www.opengis.net/gml/3.2}name) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element identifier ({http://www.opengis.net/gml/3.2}identifier) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element {http://www.opengis.net/gml/3.2}referenceEvent uses Python identifier referenceEvent
    __referenceEvent = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'referenceEvent'), 'referenceEvent', '__httpwww_opengis_netgml3_2_TimeCalendarEraType_httpwww_opengis_netgml3_2referenceEvent', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporalReferenceSystems.xsd', 82, 5), )

    
    referenceEvent = property(__referenceEvent.value, __referenceEvent.set, None, None)

    
    # Element {http://www.opengis.net/gml/3.2}referenceDate uses Python identifier referenceDate
    __referenceDate = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'referenceDate'), 'referenceDate', '__httpwww_opengis_netgml3_2_TimeCalendarEraType_httpwww_opengis_netgml3_2referenceDate', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporalReferenceSystems.xsd', 83, 5), )

    
    referenceDate = property(__referenceDate.value, __referenceDate.set, None, None)

    
    # Element {http://www.opengis.net/gml/3.2}julianReference uses Python identifier julianReference
    __julianReference = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'julianReference'), 'julianReference', '__httpwww_opengis_netgml3_2_TimeCalendarEraType_httpwww_opengis_netgml3_2julianReference', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporalReferenceSystems.xsd', 84, 5), )

    
    julianReference = property(__julianReference.value, __julianReference.set, None, None)

    
    # Element {http://www.opengis.net/gml/3.2}epochOfUse uses Python identifier epochOfUse
    __epochOfUse = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'epochOfUse'), 'epochOfUse', '__httpwww_opengis_netgml3_2_TimeCalendarEraType_httpwww_opengis_netgml3_2epochOfUse', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporalReferenceSystems.xsd', 85, 5), )

    
    epochOfUse = property(__epochOfUse.value, __epochOfUse.set, None, None)

    
    # Attribute id_ inherited from {http://www.opengis.net/gml/3.2}DefinitionBaseType
    _ElementMap.update({
        __referenceEvent.name() : __referenceEvent,
        __referenceDate.name() : __referenceDate,
        __julianReference.name() : __julianReference,
        __epochOfUse.name() : __epochOfUse
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.TimeCalendarEraType = TimeCalendarEraType
_Namespace_gml.addCategoryObject('typeBinding', 'TimeCalendarEraType', TimeCalendarEraType)


# Complex type {http://www.opengis.net/gml/3.2}TimeOrdinalEraType with content type ELEMENT_ONLY
class TimeOrdinalEraType (DefinitionType):
    """Complex type {http://www.opengis.net/gml/3.2}TimeOrdinalEraType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'TimeOrdinalEraType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporalReferenceSystems.xsd', 165, 1)
    _ElementMap = DefinitionType._ElementMap.copy()
    _AttributeMap = DefinitionType._AttributeMap.copy()
    # Base type is DefinitionType
    
    # Element metaDataProperty ({http://www.opengis.net/gml/3.2}metaDataProperty) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element remarks ({http://www.opengis.net/gml/3.2}remarks) inherited from {http://www.opengis.net/gml/3.2}DefinitionType
    
    # Element description ({http://www.opengis.net/gml/3.2}description) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element descriptionReference ({http://www.opengis.net/gml/3.2}descriptionReference) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element name ({http://www.opengis.net/gml/3.2}name) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element identifier ({http://www.opengis.net/gml/3.2}identifier) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element {http://www.opengis.net/gml/3.2}relatedTime uses Python identifier relatedTime
    __relatedTime = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'relatedTime'), 'relatedTime', '__httpwww_opengis_netgml3_2_TimeOrdinalEraType_httpwww_opengis_netgml3_2relatedTime', True, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporalReferenceSystems.xsd', 169, 5), )

    
    relatedTime = property(__relatedTime.value, __relatedTime.set, None, None)

    
    # Element {http://www.opengis.net/gml/3.2}start uses Python identifier start
    __start = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'start'), 'start', '__httpwww_opengis_netgml3_2_TimeOrdinalEraType_httpwww_opengis_netgml3_2start', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporalReferenceSystems.xsd', 170, 5), )

    
    start = property(__start.value, __start.set, None, None)

    
    # Element {http://www.opengis.net/gml/3.2}end uses Python identifier end
    __end = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'end'), 'end', '__httpwww_opengis_netgml3_2_TimeOrdinalEraType_httpwww_opengis_netgml3_2end', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporalReferenceSystems.xsd', 171, 5), )

    
    end = property(__end.value, __end.set, None, None)

    
    # Element {http://www.opengis.net/gml/3.2}extent uses Python identifier extent
    __extent = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'extent'), 'extent', '__httpwww_opengis_netgml3_2_TimeOrdinalEraType_httpwww_opengis_netgml3_2extent', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporalReferenceSystems.xsd', 172, 5), )

    
    extent = property(__extent.value, __extent.set, None, None)

    
    # Element {http://www.opengis.net/gml/3.2}member uses Python identifier member
    __member = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'member'), 'member', '__httpwww_opengis_netgml3_2_TimeOrdinalEraType_httpwww_opengis_netgml3_2member', True, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporalReferenceSystems.xsd', 173, 5), )

    
    member = property(__member.value, __member.set, None, None)

    
    # Element {http://www.opengis.net/gml/3.2}group uses Python identifier group
    __group = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'group'), 'group', '__httpwww_opengis_netgml3_2_TimeOrdinalEraType_httpwww_opengis_netgml3_2group', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporalReferenceSystems.xsd', 174, 5), )

    
    group = property(__group.value, __group.set, None, None)

    
    # Attribute id_ inherited from {http://www.opengis.net/gml/3.2}DefinitionBaseType
    _ElementMap.update({
        __relatedTime.name() : __relatedTime,
        __start.name() : __start,
        __end.name() : __end,
        __extent.name() : __extent,
        __member.name() : __member,
        __group.name() : __group
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.TimeOrdinalEraType = TimeOrdinalEraType
_Namespace_gml.addCategoryObject('typeBinding', 'TimeOrdinalEraType', TimeOrdinalEraType)


# Complex type {http://www.opengis.net/gml/3.2}AbstractTimeTopologyPrimitiveType with content type ELEMENT_ONLY
class AbstractTimeTopologyPrimitiveType (AbstractTimePrimitiveType):
    """Complex type {http://www.opengis.net/gml/3.2}AbstractTimeTopologyPrimitiveType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = True
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractTimeTopologyPrimitiveType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporalTopology.xsd', 22, 1)
    _ElementMap = AbstractTimePrimitiveType._ElementMap.copy()
    _AttributeMap = AbstractTimePrimitiveType._AttributeMap.copy()
    # Base type is AbstractTimePrimitiveType
    
    # Element metaDataProperty ({http://www.opengis.net/gml/3.2}metaDataProperty) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element description ({http://www.opengis.net/gml/3.2}description) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element descriptionReference ({http://www.opengis.net/gml/3.2}descriptionReference) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element name ({http://www.opengis.net/gml/3.2}name) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element identifier ({http://www.opengis.net/gml/3.2}identifier) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element relatedTime ({http://www.opengis.net/gml/3.2}relatedTime) inherited from {http://www.opengis.net/gml/3.2}AbstractTimePrimitiveType
    
    # Element {http://www.opengis.net/gml/3.2}complex uses Python identifier complex
    __complex = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'complex'), 'complex', '__httpwww_opengis_netgml3_2_AbstractTimeTopologyPrimitiveType_httpwww_opengis_netgml3_2complex', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporalTopology.xsd', 26, 5), )

    
    complex = property(__complex.value, __complex.set, None, None)

    
    # Attribute id inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    _ElementMap.update({
        __complex.name() : __complex
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.AbstractTimeTopologyPrimitiveType = AbstractTimeTopologyPrimitiveType
_Namespace_gml.addCategoryObject('typeBinding', 'AbstractTimeTopologyPrimitiveType', AbstractTimeTopologyPrimitiveType)


# Complex type {http://www.opengis.net/gml/3.2}TimeTopologyComplexType with content type ELEMENT_ONLY
class TimeTopologyComplexType (AbstractTimeComplexType):
    """Complex type {http://www.opengis.net/gml/3.2}TimeTopologyComplexType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = True
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'TimeTopologyComplexType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporalTopology.xsd', 48, 1)
    _ElementMap = AbstractTimeComplexType._ElementMap.copy()
    _AttributeMap = AbstractTimeComplexType._AttributeMap.copy()
    # Base type is AbstractTimeComplexType
    
    # Element metaDataProperty ({http://www.opengis.net/gml/3.2}metaDataProperty) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element description ({http://www.opengis.net/gml/3.2}description) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element descriptionReference ({http://www.opengis.net/gml/3.2}descriptionReference) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element name ({http://www.opengis.net/gml/3.2}name) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element identifier ({http://www.opengis.net/gml/3.2}identifier) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element {http://www.opengis.net/gml/3.2}primitive uses Python identifier primitive
    __primitive = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'primitive'), 'primitive', '__httpwww_opengis_netgml3_2_TimeTopologyComplexType_httpwww_opengis_netgml3_2primitive', True, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporalTopology.xsd', 52, 5), )

    
    primitive = property(__primitive.value, __primitive.set, None, None)

    
    # Attribute id inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    _ElementMap.update({
        __primitive.name() : __primitive
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.TimeTopologyComplexType = TimeTopologyComplexType
_Namespace_gml.addCategoryObject('typeBinding', 'TimeTopologyComplexType', TimeTopologyComplexType)


# Complex type {http://www.opengis.net/gml/3.2}NodeType with content type ELEMENT_ONLY
class NodeType (AbstractTopoPrimitiveType):
    """Complex type {http://www.opengis.net/gml/3.2}NodeType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'NodeType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/topology.xsd', 67, 2)
    _ElementMap = AbstractTopoPrimitiveType._ElementMap.copy()
    _AttributeMap = AbstractTopoPrimitiveType._AttributeMap.copy()
    # Base type is AbstractTopoPrimitiveType
    
    # Element metaDataProperty ({http://www.opengis.net/gml/3.2}metaDataProperty) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element {http://www.opengis.net/gml/3.2}pointProperty uses Python identifier pointProperty
    __pointProperty = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'pointProperty'), 'pointProperty', '__httpwww_opengis_netgml3_2_NodeType_httpwww_opengis_netgml3_2pointProperty', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic0d1d.xsd', 204, 1), )

    
    pointProperty = property(__pointProperty.value, __pointProperty.set, None, 'This property element either references a point via the XLink-attributes or contains the point element. pointProperty is the predefined property which may be used by GML Application Schemas whenever a GML feature has a property with a value that is substitutable for Point.')

    
    # Element description ({http://www.opengis.net/gml/3.2}description) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element descriptionReference ({http://www.opengis.net/gml/3.2}descriptionReference) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element name ({http://www.opengis.net/gml/3.2}name) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element identifier ({http://www.opengis.net/gml/3.2}identifier) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element {http://www.opengis.net/gml/3.2}container uses Python identifier container
    __container = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'container'), 'container', '__httpwww_opengis_netgml3_2_NodeType_httpwww_opengis_netgml3_2container', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/topology.xsd', 71, 10), )

    
    container = property(__container.value, __container.set, None, None)

    
    # Element {http://www.opengis.net/gml/3.2}directedEdge uses Python identifier directedEdge
    __directedEdge = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'directedEdge'), 'directedEdge', '__httpwww_opengis_netgml3_2_NodeType_httpwww_opengis_netgml3_2directedEdge', True, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/topology.xsd', 126, 2), )

    
    directedEdge = property(__directedEdge.value, __directedEdge.set, None, 'A gml:directedEdge property element describes the boundary of topology faces, the coBoundary of topology nodes and is used in the support of topological line features via the gml:TopoCurve expression, see below. The orientation attribute of type gml:SignType expresses the sense in which the included edge is used, i.e. forward or reverse.')

    
    # Attribute id inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Attribute aggregationType uses Python identifier aggregationType
    __aggregationType = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'aggregationType'), 'aggregationType', '__httpwww_opengis_netgml3_2_NodeType_aggregationType', _module_typeBindings.AggregationType)
    __aggregationType._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 158, 2)
    __aggregationType._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 158, 2)
    
    aggregationType = property(__aggregationType.value, __aggregationType.set, None, None)

    _ElementMap.update({
        __pointProperty.name() : __pointProperty,
        __container.name() : __container,
        __directedEdge.name() : __directedEdge
    })
    _AttributeMap.update({
        __aggregationType.name() : __aggregationType
    })
_module_typeBindings.NodeType = NodeType
_Namespace_gml.addCategoryObject('typeBinding', 'NodeType', NodeType)


# Complex type {http://www.opengis.net/gml/3.2}EdgeType with content type ELEMENT_ONLY
class EdgeType (AbstractTopoPrimitiveType):
    """Complex type {http://www.opengis.net/gml/3.2}EdgeType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'EdgeType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/topology.xsd', 104, 2)
    _ElementMap = AbstractTopoPrimitiveType._ElementMap.copy()
    _AttributeMap = AbstractTopoPrimitiveType._AttributeMap.copy()
    # Base type is AbstractTopoPrimitiveType
    
    # Element metaDataProperty ({http://www.opengis.net/gml/3.2}metaDataProperty) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element {http://www.opengis.net/gml/3.2}curveProperty uses Python identifier curveProperty
    __curveProperty = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'curveProperty'), 'curveProperty', '__httpwww_opengis_netgml3_2_EdgeType_httpwww_opengis_netgml3_2curveProperty', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic0d1d.xsd', 241, 1), )

    
    curveProperty = property(__curveProperty.value, __curveProperty.set, None, 'This property element either references a curve via the XLink-attributes or contains the curve element. curveProperty is the predefined property which may be used by GML Application Schemas whenever a GML feature has a property with a value that is substitutable for AbstractCurve.')

    
    # Element description ({http://www.opengis.net/gml/3.2}description) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element descriptionReference ({http://www.opengis.net/gml/3.2}descriptionReference) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element name ({http://www.opengis.net/gml/3.2}name) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element identifier ({http://www.opengis.net/gml/3.2}identifier) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element {http://www.opengis.net/gml/3.2}directedNode uses Python identifier directedNode
    __directedNode = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'directedNode'), 'directedNode', '__httpwww_opengis_netgml3_2_EdgeType_httpwww_opengis_netgml3_2directedNode', True, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/topology.xsd', 91, 2), )

    
    directedNode = property(__directedNode.value, __directedNode.set, None, 'A gml:directedNode property element describes the boundary of topology edges and is used in the support of topological point features via the gml:TopoPoint expression, see below. The orientation attribute of type gml:SignType expresses the sense in which the included node is used: start ("-") or end ("+") node.')

    
    # Element {http://www.opengis.net/gml/3.2}container uses Python identifier container
    __container = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'container'), 'container', '__httpwww_opengis_netgml3_2_EdgeType_httpwww_opengis_netgml3_2container', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/topology.xsd', 108, 10), )

    
    container = property(__container.value, __container.set, None, None)

    
    # Element {http://www.opengis.net/gml/3.2}directedFace uses Python identifier directedFace
    __directedFace = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'directedFace'), 'directedFace', '__httpwww_opengis_netgml3_2_EdgeType_httpwww_opengis_netgml3_2directedFace', True, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/topology.xsd', 165, 2), )

    
    directedFace = property(__directedFace.value, __directedFace.set, None, 'The gml:directedFace property element describes the boundary of topology solids, in the coBoundary of topology edges and is used in the support of surface features via the gml:TopoSurface expression, see below. The orientation attribute of type gml:SignType expresses the sense in which the included face is used i.e. inward or outward with respect to the surface normal in any geometric realisation.')

    
    # Attribute id inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Attribute aggregationType uses Python identifier aggregationType
    __aggregationType = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'aggregationType'), 'aggregationType', '__httpwww_opengis_netgml3_2_EdgeType_aggregationType', _module_typeBindings.AggregationType)
    __aggregationType._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 158, 2)
    __aggregationType._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 158, 2)
    
    aggregationType = property(__aggregationType.value, __aggregationType.set, None, None)

    _ElementMap.update({
        __curveProperty.name() : __curveProperty,
        __directedNode.name() : __directedNode,
        __container.name() : __container,
        __directedFace.name() : __directedFace
    })
    _AttributeMap.update({
        __aggregationType.name() : __aggregationType
    })
_module_typeBindings.EdgeType = EdgeType
_Namespace_gml.addCategoryObject('typeBinding', 'EdgeType', EdgeType)


# Complex type {http://www.opengis.net/gml/3.2}FaceType with content type ELEMENT_ONLY
class FaceType (AbstractTopoPrimitiveType):
    """Complex type {http://www.opengis.net/gml/3.2}FaceType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'FaceType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/topology.xsd', 139, 2)
    _ElementMap = AbstractTopoPrimitiveType._ElementMap.copy()
    _AttributeMap = AbstractTopoPrimitiveType._AttributeMap.copy()
    # Base type is AbstractTopoPrimitiveType
    
    # Element metaDataProperty ({http://www.opengis.net/gml/3.2}metaDataProperty) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element {http://www.opengis.net/gml/3.2}surfaceProperty uses Python identifier surfaceProperty
    __surfaceProperty = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'surfaceProperty'), 'surfaceProperty', '__httpwww_opengis_netgml3_2_FaceType_httpwww_opengis_netgml3_2surfaceProperty', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic2d.xsd', 37, 1), )

    
    surfaceProperty = property(__surfaceProperty.value, __surfaceProperty.set, None, 'This property element either references a surface via the XLink-attributes or contains the surface element. surfaceProperty is the predefined property which may be used by GML Application Schemas whenever a GML feature has a property with a value that is substitutable for AbstractSurface.')

    
    # Element description ({http://www.opengis.net/gml/3.2}description) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element descriptionReference ({http://www.opengis.net/gml/3.2}descriptionReference) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element name ({http://www.opengis.net/gml/3.2}name) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element identifier ({http://www.opengis.net/gml/3.2}identifier) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element {http://www.opengis.net/gml/3.2}directedEdge uses Python identifier directedEdge
    __directedEdge = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'directedEdge'), 'directedEdge', '__httpwww_opengis_netgml3_2_FaceType_httpwww_opengis_netgml3_2directedEdge', True, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/topology.xsd', 126, 2), )

    
    directedEdge = property(__directedEdge.value, __directedEdge.set, None, 'A gml:directedEdge property element describes the boundary of topology faces, the coBoundary of topology nodes and is used in the support of topological line features via the gml:TopoCurve expression, see below. The orientation attribute of type gml:SignType expresses the sense in which the included edge is used, i.e. forward or reverse.')

    
    # Element {http://www.opengis.net/gml/3.2}isolated uses Python identifier isolated
    __isolated = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'isolated'), 'isolated', '__httpwww_opengis_netgml3_2_FaceType_httpwww_opengis_netgml3_2isolated', True, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/topology.xsd', 143, 10), )

    
    isolated = property(__isolated.value, __isolated.set, None, None)

    
    # Element {http://www.opengis.net/gml/3.2}directedTopoSolid uses Python identifier directedTopoSolid
    __directedTopoSolid = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'directedTopoSolid'), 'directedTopoSolid', '__httpwww_opengis_netgml3_2_FaceType_httpwww_opengis_netgml3_2directedTopoSolid', True, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/topology.xsd', 202, 2), )

    
    directedTopoSolid = property(__directedTopoSolid.value, __directedTopoSolid.set, None, 'The gml:directedSolid property element describes the coBoundary of topology faces and is used in the support of volume features via the gml:TopoVolume expression, see below. The orientation attribute of type gml:SignType expresses the sense in which the included solid appears in the face coboundary. In the context of a gml:TopoVolume the orientation attribute has no meaning.')

    
    # Attribute id inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Attribute aggregationType uses Python identifier aggregationType
    __aggregationType = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'aggregationType'), 'aggregationType', '__httpwww_opengis_netgml3_2_FaceType_aggregationType', _module_typeBindings.AggregationType)
    __aggregationType._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 158, 2)
    __aggregationType._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 158, 2)
    
    aggregationType = property(__aggregationType.value, __aggregationType.set, None, None)

    
    # Attribute universal uses Python identifier universal
    __universal = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'universal'), 'universal', '__httpwww_opengis_netgml3_2_FaceType_universal', pyxb.binding.datatypes.boolean, unicode_default='false')
    __universal._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/topology.xsd', 149, 8)
    __universal._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/topology.xsd', 149, 8)
    
    universal = property(__universal.value, __universal.set, None, 'If the topological representation exists an unbounded manifold (e.g. Euclidean plane), a gml:Face must indicate whether it is a universal face or not, to ensure a lossless topology representation as defined by Kuijpers, et. al. (see OGC 05-102 Topology IPR). The optional universal attribute of type boolean is used to indicate this. NOTE The universal face is normally not part of any feature, and is used to represent the unbounded portion of the data set. Its interior boundary (it has no exterior boundary) would normally be considered the exterior boundary of the map represented by the data set. ')

    _ElementMap.update({
        __surfaceProperty.name() : __surfaceProperty,
        __directedEdge.name() : __directedEdge,
        __isolated.name() : __isolated,
        __directedTopoSolid.name() : __directedTopoSolid
    })
    _AttributeMap.update({
        __aggregationType.name() : __aggregationType,
        __universal.name() : __universal
    })
_module_typeBindings.FaceType = FaceType
_Namespace_gml.addCategoryObject('typeBinding', 'FaceType', FaceType)


# Complex type {http://www.opengis.net/gml/3.2}TopoSolidType with content type ELEMENT_ONLY
class TopoSolidType (AbstractTopoPrimitiveType):
    """Complex type {http://www.opengis.net/gml/3.2}TopoSolidType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'TopoSolidType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/topology.xsd', 178, 2)
    _ElementMap = AbstractTopoPrimitiveType._ElementMap.copy()
    _AttributeMap = AbstractTopoPrimitiveType._AttributeMap.copy()
    # Base type is AbstractTopoPrimitiveType
    
    # Element metaDataProperty ({http://www.opengis.net/gml/3.2}metaDataProperty) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element {http://www.opengis.net/gml/3.2}solidProperty uses Python identifier solidProperty
    __solidProperty = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'solidProperty'), 'solidProperty', '__httpwww_opengis_netgml3_2_TopoSolidType_httpwww_opengis_netgml3_2solidProperty', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 790, 1), )

    
    solidProperty = property(__solidProperty.value, __solidProperty.set, None, 'This property element either references a solid via the XLink-attributes or contains the solid element. solidProperty is the predefined property which may be used by GML Application Schemas whenever a GML feature has a property with a value that is substitutable for AbstractSolid.')

    
    # Element description ({http://www.opengis.net/gml/3.2}description) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element descriptionReference ({http://www.opengis.net/gml/3.2}descriptionReference) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element name ({http://www.opengis.net/gml/3.2}name) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element identifier ({http://www.opengis.net/gml/3.2}identifier) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element {http://www.opengis.net/gml/3.2}directedFace uses Python identifier directedFace
    __directedFace = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'directedFace'), 'directedFace', '__httpwww_opengis_netgml3_2_TopoSolidType_httpwww_opengis_netgml3_2directedFace', True, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/topology.xsd', 165, 2), )

    
    directedFace = property(__directedFace.value, __directedFace.set, None, 'The gml:directedFace property element describes the boundary of topology solids, in the coBoundary of topology edges and is used in the support of surface features via the gml:TopoSurface expression, see below. The orientation attribute of type gml:SignType expresses the sense in which the included face is used i.e. inward or outward with respect to the surface normal in any geometric realisation.')

    
    # Element {http://www.opengis.net/gml/3.2}isolated uses Python identifier isolated
    __isolated = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'isolated'), 'isolated', '__httpwww_opengis_netgml3_2_TopoSolidType_httpwww_opengis_netgml3_2isolated', True, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/topology.xsd', 182, 10), )

    
    isolated = property(__isolated.value, __isolated.set, None, None)

    
    # Attribute id inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Attribute aggregationType uses Python identifier aggregationType
    __aggregationType = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'aggregationType'), 'aggregationType', '__httpwww_opengis_netgml3_2_TopoSolidType_aggregationType', _module_typeBindings.AggregationType)
    __aggregationType._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 158, 2)
    __aggregationType._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 158, 2)
    
    aggregationType = property(__aggregationType.value, __aggregationType.set, None, None)

    
    # Attribute universal uses Python identifier universal
    __universal = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'universal'), 'universal', '__httpwww_opengis_netgml3_2_TopoSolidType_universal', pyxb.binding.datatypes.boolean, unicode_default='false')
    __universal._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/topology.xsd', 187, 8)
    __universal._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/topology.xsd', 187, 8)
    
    universal = property(__universal.value, __universal.set, None, 'A gml:TopoSolid must indicate whether it is a universal topo-solid or not, to ensure a lossless topology representation as defined by Kuijpers, et. al. (see OGC 05-102 Topology IPR). The optional universal attribute of type boolean is used to indicate this and the default is fault. NOTE The universal topo-solid is normally not part of any feature, and is used to represent the unbounded portion of the data set. Its interior boundary (it has no exterior boundary) would normally be considered the exterior boundary of the data set.')

    _ElementMap.update({
        __solidProperty.name() : __solidProperty,
        __directedFace.name() : __directedFace,
        __isolated.name() : __isolated
    })
    _AttributeMap.update({
        __aggregationType.name() : __aggregationType,
        __universal.name() : __universal
    })
_module_typeBindings.TopoSolidType = TopoSolidType
_Namespace_gml.addCategoryObject('typeBinding', 'TopoSolidType', TopoSolidType)


# Complex type {http://www.opengis.net/gml/3.2}UnitDefinitionType with content type ELEMENT_ONLY
class UnitDefinitionType (DefinitionType):
    """Complex type {http://www.opengis.net/gml/3.2}UnitDefinitionType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'UnitDefinitionType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/units.xsd', 37, 1)
    _ElementMap = DefinitionType._ElementMap.copy()
    _AttributeMap = DefinitionType._AttributeMap.copy()
    # Base type is DefinitionType
    
    # Element metaDataProperty ({http://www.opengis.net/gml/3.2}metaDataProperty) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element remarks ({http://www.opengis.net/gml/3.2}remarks) inherited from {http://www.opengis.net/gml/3.2}DefinitionType
    
    # Element description ({http://www.opengis.net/gml/3.2}description) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element descriptionReference ({http://www.opengis.net/gml/3.2}descriptionReference) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element name ({http://www.opengis.net/gml/3.2}name) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element identifier ({http://www.opengis.net/gml/3.2}identifier) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element {http://www.opengis.net/gml/3.2}quantityType uses Python identifier quantityType
    __quantityType = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'quantityType'), 'quantityType', '__httpwww_opengis_netgml3_2_UnitDefinitionType_httpwww_opengis_netgml3_2quantityType', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/units.xsd', 48, 1), )

    
    quantityType = property(__quantityType.value, __quantityType.set, None, 'The gml:quantityType property indicates the phenomenon to which the units apply. This element contains an informal description of the phenomenon or type of physical quantity that is measured or observed. When the physical quantity is the result of an observation or measurement, this term is known as observable type or measurand.\nThe use of gml:quantityType for references to remote values is deprecated.')

    
    # Element {http://www.opengis.net/gml/3.2}quantityTypeReference uses Python identifier quantityTypeReference
    __quantityTypeReference = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'quantityTypeReference'), 'quantityTypeReference', '__httpwww_opengis_netgml3_2_UnitDefinitionType_httpwww_opengis_netgml3_2quantityTypeReference', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/units.xsd', 54, 1), )

    
    quantityTypeReference = property(__quantityTypeReference.value, __quantityTypeReference.set, None, 'The gml:quantityTypeReference property indicates the phenomenon to which the units apply. The content is a reference to a remote value.')

    
    # Element {http://www.opengis.net/gml/3.2}catalogSymbol uses Python identifier catalogSymbol
    __catalogSymbol = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'catalogSymbol'), 'catalogSymbol', '__httpwww_opengis_netgml3_2_UnitDefinitionType_httpwww_opengis_netgml3_2catalogSymbol', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/units.xsd', 59, 1), )

    
    catalogSymbol = property(__catalogSymbol.value, __catalogSymbol.set, None, 'The catalogSymbol is the preferred lexical symbol used for this unit of measure.\nThe codeSpace attribute in gml:CodeType identifies a namespace for the catalog symbol value, and might reference the external catalog. The string value in gml:CodeType contains the value of a symbol that should be unique within this catalog namespace. This symbol often appears explicitly in the catalog, but it could be a combination of symbols using a specified algebra of units.')

    
    # Attribute id_ inherited from {http://www.opengis.net/gml/3.2}DefinitionBaseType
    _ElementMap.update({
        __quantityType.name() : __quantityType,
        __quantityTypeReference.name() : __quantityTypeReference,
        __catalogSymbol.name() : __catalogSymbol
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.UnitDefinitionType = UnitDefinitionType
_Namespace_gml.addCategoryObject('typeBinding', 'UnitDefinitionType', UnitDefinitionType)


# Complex type {http://www.opengis.net/gml/3.2}DerivationUnitTermType with content type EMPTY
class DerivationUnitTermType (UnitOfMeasureType):
    """Complex type {http://www.opengis.net/gml/3.2}DerivationUnitTermType with content type EMPTY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_EMPTY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'DerivationUnitTermType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/units.xsd', 101, 1)
    _ElementMap = UnitOfMeasureType._ElementMap.copy()
    _AttributeMap = UnitOfMeasureType._AttributeMap.copy()
    # Base type is UnitOfMeasureType
    
    # Attribute uom inherited from {http://www.opengis.net/gml/3.2}UnitOfMeasureType
    
    # Attribute exponent uses Python identifier exponent
    __exponent = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'exponent'), 'exponent', '__httpwww_opengis_netgml3_2_DerivationUnitTermType_exponent', pyxb.binding.datatypes.integer)
    __exponent._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/units.xsd', 104, 4)
    __exponent._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/units.xsd', 104, 4)
    
    exponent = property(__exponent.value, __exponent.set, None, None)

    _ElementMap.update({
        
    })
    _AttributeMap.update({
        __exponent.name() : __exponent
    })
_module_typeBindings.DerivationUnitTermType = DerivationUnitTermType
_Namespace_gml.addCategoryObject('typeBinding', 'DerivationUnitTermType', DerivationUnitTermType)


# Complex type {http://www.opengis.net/gml/3.2}ConversionToPreferredUnitType with content type ELEMENT_ONLY
class ConversionToPreferredUnitType (UnitOfMeasureType):
    """The inherited attribute uom references the preferred unit that this conversion applies to. The conversion of a unit to the preferred unit for this physical quantity type is specified by an arithmetic conversion (scaling and/or offset). The content model extends gml:UnitOfMeasureType, which has a mandatory attribute uom which identifies the preferred unit for the physical quantity type that this conversion applies to. The conversion is specified by a choice of 
-	gml:factor, which defines the scale factor, or
-	gml:formula, which defines a formula 
by which a value using the conventional unit of measure can be converted to obtain the corresponding value using the preferred unit of measure.  
The formula defines the parameters of a simple formula by which a value using the conventional unit of measure can be converted to the corresponding value using the preferred unit of measure. The formula element contains elements a, b, c and d, whose values use the XML Schema type double. These values are used in the formula y = (a + bx) / (c + dx), where x is a value using this unit, and y is the corresponding value using the base unit. The elements a and d are optional, and if values are not provided, those parameters are considered to be zero. If values are not provided for both a and d, the formula is equivalent to a fraction with numerator and denominator parameters."""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'ConversionToPreferredUnitType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/units.xsd', 137, 1)
    _ElementMap = UnitOfMeasureType._ElementMap.copy()
    _AttributeMap = UnitOfMeasureType._AttributeMap.copy()
    # Base type is UnitOfMeasureType
    
    # Element {http://www.opengis.net/gml/3.2}factor uses Python identifier factor
    __factor = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'factor'), 'factor', '__httpwww_opengis_netgml3_2_ConversionToPreferredUnitType_httpwww_opengis_netgml3_2factor', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/units.xsd', 148, 5), )

    
    factor = property(__factor.value, __factor.set, None, None)

    
    # Element {http://www.opengis.net/gml/3.2}formula uses Python identifier formula
    __formula = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'formula'), 'formula', '__httpwww_opengis_netgml3_2_ConversionToPreferredUnitType_httpwww_opengis_netgml3_2formula', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/units.xsd', 149, 5), )

    
    formula = property(__formula.value, __formula.set, None, None)

    
    # Attribute uom inherited from {http://www.opengis.net/gml/3.2}UnitOfMeasureType
    _ElementMap.update({
        __factor.name() : __factor,
        __formula.name() : __formula
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.ConversionToPreferredUnitType = ConversionToPreferredUnitType
_Namespace_gml.addCategoryObject('typeBinding', 'ConversionToPreferredUnitType', ConversionToPreferredUnitType)


# Complex type [anonymous] with content type SIMPLE
class CTD_ANON_12 (MeasureType):
    """An XML attribute uom ("unit of measure") is required, whose value is a URI which identifies the definition of a ratio scale or units by which the numeric value shall be multiplied, or an interval or position scale on which the value occurs."""
    _TypeDefinition = pyxb.binding.datatypes.double
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_SIMPLE
    _Abstract = False
    _ExpandedName = None
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/valueObjects.xsd', 61, 2)
    _ElementMap = MeasureType._ElementMap.copy()
    _AttributeMap = MeasureType._AttributeMap.copy()
    # Base type is MeasureType
    
    # Attribute uom inherited from {http://www.opengis.net/gml/3.2}MeasureType
    
    # Attribute nilReason uses Python identifier nilReason
    __nilReason = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'nilReason'), 'nilReason', '__httpwww_opengis_netgml3_2_CTD_ANON_12_nilReason', _module_typeBindings.NilReasonType)
    __nilReason._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/valueObjects.xsd', 64, 5)
    __nilReason._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/valueObjects.xsd', 64, 5)
    
    nilReason = property(__nilReason.value, __nilReason.set, None, None)

    _ElementMap.update({
        
    })
    _AttributeMap.update({
        __nilReason.name() : __nilReason
    })
_module_typeBindings.CTD_ANON_12 = CTD_ANON_12


# Complex type {http://www.opengis.net/gml/3.2}AbstractCoordinateOperationType with content type ELEMENT_ONLY
class AbstractCoordinateOperationType (IdentifiedObjectType):
    """Complex type {http://www.opengis.net/gml/3.2}AbstractCoordinateOperationType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = True
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractCoordinateOperationType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 29, 1)
    _ElementMap = IdentifiedObjectType._ElementMap.copy()
    _AttributeMap = IdentifiedObjectType._AttributeMap.copy()
    # Base type is IdentifiedObjectType
    
    # Element {http://www.opengis.net/gml/3.2}operationVersion uses Python identifier operationVersion
    __operationVersion = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'operationVersion'), 'operationVersion', '__httpwww_opengis_netgml3_2_AbstractCoordinateOperationType_httpwww_opengis_netgml3_2operationVersion', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 43, 1), )

    
    operationVersion = property(__operationVersion.value, __operationVersion.set, None, 'gml:operationVersion is the version of the coordinate transformation (i.e., instantiation due to the stochastic nature of the parameters). Mandatory when describing a transformation, and should not be supplied for a conversion.')

    
    # Element {http://www.opengis.net/gml/3.2}coordinateOperationAccuracy uses Python identifier coordinateOperationAccuracy
    __coordinateOperationAccuracy = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'coordinateOperationAccuracy'), 'coordinateOperationAccuracy', '__httpwww_opengis_netgml3_2_AbstractCoordinateOperationType_httpwww_opengis_netgml3_2coordinateOperationAccuracy', True, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 48, 1), )

    
    coordinateOperationAccuracy = property(__coordinateOperationAccuracy.value, __coordinateOperationAccuracy.set, None, 'gml:coordinateOperationAccuracy is an association role to a DQ_PositionalAccuracy object as encoded in ISO/TS 19139, either referencing or containing the definition of that positional accuracy. That object contains an estimate of the impact of this coordinate operation on point accuracy. That is, it gives position error estimates for the target coordinates of this coordinate operation, assuming no errors in the source coordinates.')

    
    # Element {http://www.opengis.net/gml/3.2}sourceCRS uses Python identifier sourceCRS
    __sourceCRS = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'sourceCRS'), 'sourceCRS', '__httpwww_opengis_netgml3_2_AbstractCoordinateOperationType_httpwww_opengis_netgml3_2sourceCRS', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 59, 1), )

    
    sourceCRS = property(__sourceCRS.value, __sourceCRS.set, None, 'gml:sourceCRS is an association role to the source CRS (coordinate reference system) of this coordinate operation.')

    
    # Element {http://www.opengis.net/gml/3.2}targetCRS uses Python identifier targetCRS
    __targetCRS = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'targetCRS'), 'targetCRS', '__httpwww_opengis_netgml3_2_AbstractCoordinateOperationType_httpwww_opengis_netgml3_2targetCRS', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 64, 1), )

    
    targetCRS = property(__targetCRS.value, __targetCRS.set, None, 'gml:targetCRS is an association role to the target CRS (coordinate reference system) of this coordinate operation.')

    
    # Element metaDataProperty ({http://www.opengis.net/gml/3.2}metaDataProperty) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element remarks ({http://www.opengis.net/gml/3.2}remarks) inherited from {http://www.opengis.net/gml/3.2}DefinitionType
    
    # Element description ({http://www.opengis.net/gml/3.2}description) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element descriptionReference ({http://www.opengis.net/gml/3.2}descriptionReference) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element name ({http://www.opengis.net/gml/3.2}name) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element identifier ({http://www.opengis.net/gml/3.2}identifier) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element {http://www.opengis.net/gml/3.2}domainOfValidity uses Python identifier domainOfValidity
    __domainOfValidity = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'domainOfValidity'), 'domainOfValidity', '__httpwww_opengis_netgml3_2_AbstractCoordinateOperationType_httpwww_opengis_netgml3_2domainOfValidity', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/referenceSystems.xsd', 45, 1), )

    
    domainOfValidity = property(__domainOfValidity.value, __domainOfValidity.set, None, 'The gml:domainOfValidity property implements an association role to an EX_Extent object as encoded in ISO/TS 19139, either referencing or containing the definition of that extent.')

    
    # Element {http://www.opengis.net/gml/3.2}scope uses Python identifier scope
    __scope = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'scope'), 'scope', '__httpwww_opengis_netgml3_2_AbstractCoordinateOperationType_httpwww_opengis_netgml3_2scope', True, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/referenceSystems.xsd', 56, 1), )

    
    scope = property(__scope.value, __scope.set, None, 'The gml:scope property provides a description of the usage, or limitations of usage, for which this CRS-related object is valid. If unknown, enter "not known".')

    
    # Attribute id_ inherited from {http://www.opengis.net/gml/3.2}DefinitionBaseType
    _ElementMap.update({
        __operationVersion.name() : __operationVersion,
        __coordinateOperationAccuracy.name() : __coordinateOperationAccuracy,
        __sourceCRS.name() : __sourceCRS,
        __targetCRS.name() : __targetCRS,
        __domainOfValidity.name() : __domainOfValidity,
        __scope.name() : __scope
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.AbstractCoordinateOperationType = AbstractCoordinateOperationType
_Namespace_gml.addCategoryObject('typeBinding', 'AbstractCoordinateOperationType', AbstractCoordinateOperationType)


# Complex type {http://www.opengis.net/gml/3.2}OperationMethodType with content type ELEMENT_ONLY
class OperationMethodType (IdentifiedObjectType):
    """Complex type {http://www.opengis.net/gml/3.2}OperationMethodType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'OperationMethodType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 391, 1)
    _ElementMap = IdentifiedObjectType._ElementMap.copy()
    _AttributeMap = IdentifiedObjectType._AttributeMap.copy()
    # Base type is IdentifiedObjectType
    
    # Element {http://www.opengis.net/gml/3.2}formulaCitation uses Python identifier formulaCitation
    __formulaCitation = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'formulaCitation'), 'formulaCitation', '__httpwww_opengis_netgml3_2_OperationMethodType_httpwww_opengis_netgml3_2formulaCitation', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 406, 1), )

    
    formulaCitation = property(__formulaCitation.value, __formulaCitation.set, None, 'gml:formulaCitation provides a reference to a publication giving the formula(s) or procedure used by an coordinate operation method.')

    
    # Element {http://www.opengis.net/gml/3.2}formula uses Python identifier formula
    __formula = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'formula'), 'formula', '__httpwww_opengis_netgml3_2_OperationMethodType_httpwww_opengis_netgml3_2formula', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 417, 1), )

    
    formula = property(__formula.value, __formula.set, None, 'gml:formula Formula(s) or procedure used by an operation method. The use of the codespace attribite has been deprecated. The property value shall be a character string.')

    
    # Element {http://www.opengis.net/gml/3.2}sourceDimensions uses Python identifier sourceDimensions
    __sourceDimensions = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'sourceDimensions'), 'sourceDimensions', '__httpwww_opengis_netgml3_2_OperationMethodType_httpwww_opengis_netgml3_2sourceDimensions', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 422, 1), )

    
    sourceDimensions = property(__sourceDimensions.value, __sourceDimensions.set, None, 'gml:sourceDimensions is the number of dimensions in the source CRS of this operation method.')

    
    # Element {http://www.opengis.net/gml/3.2}targetDimensions uses Python identifier targetDimensions
    __targetDimensions = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'targetDimensions'), 'targetDimensions', '__httpwww_opengis_netgml3_2_OperationMethodType_httpwww_opengis_netgml3_2targetDimensions', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 427, 1), )

    
    targetDimensions = property(__targetDimensions.value, __targetDimensions.set, None, 'gml:targetDimensions is the number of dimensions in the target CRS of this operation method.')

    
    # Element {http://www.opengis.net/gml/3.2}parameter uses Python identifier parameter
    __parameter = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'parameter'), 'parameter', '__httpwww_opengis_netgml3_2_OperationMethodType_httpwww_opengis_netgml3_2parameter', True, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 432, 1), )

    
    parameter = property(__parameter.value, __parameter.set, None, 'gml:parameter is an association to an operation parameter or parameter group.')

    
    # Element metaDataProperty ({http://www.opengis.net/gml/3.2}metaDataProperty) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element remarks ({http://www.opengis.net/gml/3.2}remarks) inherited from {http://www.opengis.net/gml/3.2}DefinitionType
    
    # Element description ({http://www.opengis.net/gml/3.2}description) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element descriptionReference ({http://www.opengis.net/gml/3.2}descriptionReference) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element name ({http://www.opengis.net/gml/3.2}name) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element identifier ({http://www.opengis.net/gml/3.2}identifier) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Attribute id_ inherited from {http://www.opengis.net/gml/3.2}DefinitionBaseType
    _ElementMap.update({
        __formulaCitation.name() : __formulaCitation,
        __formula.name() : __formula,
        __sourceDimensions.name() : __sourceDimensions,
        __targetDimensions.name() : __targetDimensions,
        __parameter.name() : __parameter
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.OperationMethodType = OperationMethodType
_Namespace_gml.addCategoryObject('typeBinding', 'OperationMethodType', OperationMethodType)


# Complex type {http://www.opengis.net/gml/3.2}AbstractGeneralOperationParameterType with content type ELEMENT_ONLY
class AbstractGeneralOperationParameterType (IdentifiedObjectType):
    """Complex type {http://www.opengis.net/gml/3.2}AbstractGeneralOperationParameterType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = True
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractGeneralOperationParameterType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 451, 1)
    _ElementMap = IdentifiedObjectType._ElementMap.copy()
    _AttributeMap = IdentifiedObjectType._AttributeMap.copy()
    # Base type is IdentifiedObjectType
    
    # Element {http://www.opengis.net/gml/3.2}minimumOccurs uses Python identifier minimumOccurs
    __minimumOccurs = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'minimumOccurs'), 'minimumOccurs', '__httpwww_opengis_netgml3_2_AbstractGeneralOperationParameterType_httpwww_opengis_netgml3_2minimumOccurs', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 460, 1), )

    
    minimumOccurs = property(__minimumOccurs.value, __minimumOccurs.set, None, 'gml:minimumOccurs is the minimum number of times that values for this parameter group or parameter are required. If this attribute is omitted, the minimum number shall be one.')

    
    # Element metaDataProperty ({http://www.opengis.net/gml/3.2}metaDataProperty) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element remarks ({http://www.opengis.net/gml/3.2}remarks) inherited from {http://www.opengis.net/gml/3.2}DefinitionType
    
    # Element description ({http://www.opengis.net/gml/3.2}description) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element descriptionReference ({http://www.opengis.net/gml/3.2}descriptionReference) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element name ({http://www.opengis.net/gml/3.2}name) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element identifier ({http://www.opengis.net/gml/3.2}identifier) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Attribute id_ inherited from {http://www.opengis.net/gml/3.2}DefinitionBaseType
    _ElementMap.update({
        __minimumOccurs.name() : __minimumOccurs
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.AbstractGeneralOperationParameterType = AbstractGeneralOperationParameterType
_Namespace_gml.addCategoryObject('typeBinding', 'AbstractGeneralOperationParameterType', AbstractGeneralOperationParameterType)


# Complex type {http://www.opengis.net/gml/3.2}CoordinateSystemAxisType with content type ELEMENT_ONLY
class CoordinateSystemAxisType (IdentifiedObjectType):
    """Complex type {http://www.opengis.net/gml/3.2}CoordinateSystemAxisType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'CoordinateSystemAxisType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateSystems.xsd', 24, 1)
    _ElementMap = IdentifiedObjectType._ElementMap.copy()
    _AttributeMap = IdentifiedObjectType._AttributeMap.copy()
    # Base type is IdentifiedObjectType
    
    # Element {http://www.opengis.net/gml/3.2}axisAbbrev uses Python identifier axisAbbrev
    __axisAbbrev = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'axisAbbrev'), 'axisAbbrev', '__httpwww_opengis_netgml3_2_CoordinateSystemAxisType_httpwww_opengis_netgml3_2axisAbbrev', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateSystems.xsd', 42, 1), )

    
    axisAbbrev = property(__axisAbbrev.value, __axisAbbrev.set, None, 'gml:axisAbbrev is the abbreviation used for this coordinate system axis; this abbreviation is also used to identify the coordinates in the coordinate tuple. The codeSpace attribute may reference a source of more information on a set of standardized abbreviations, or on this abbreviation.')

    
    # Element {http://www.opengis.net/gml/3.2}axisDirection uses Python identifier axisDirection
    __axisDirection = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'axisDirection'), 'axisDirection', '__httpwww_opengis_netgml3_2_CoordinateSystemAxisType_httpwww_opengis_netgml3_2axisDirection', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateSystems.xsd', 47, 1), )

    
    axisDirection = property(__axisDirection.value, __axisDirection.set, None, 'gml:axisDirection is the direction of this coordinate system axis (or in the case of Cartesian projected coordinates, the direction of this coordinate system axis at the origin).\nWithin any set of coordinate system axes, only one of each pair of terms may be used. For earth-fixed CRSs, this direction is often approximate and intended to provide a human interpretable meaning to the axis. When a geodetic datum is used, the precise directions of the axes may therefore vary slightly from this approximate direction.\nThe codeSpace attribute shall reference a source of information specifying the values and meanings of all the allowed string values for this property.')

    
    # Element {http://www.opengis.net/gml/3.2}minimumValue uses Python identifier minimumValue
    __minimumValue = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'minimumValue'), 'minimumValue', '__httpwww_opengis_netgml3_2_CoordinateSystemAxisType_httpwww_opengis_netgml3_2minimumValue', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateSystems.xsd', 54, 1), )

    
    minimumValue = property(__minimumValue.value, __minimumValue.set, None, 'The gml:minimumValue and gml:maximumValue properties allow the specification of minimum and maximum value normally allowed for this axis, in the unit of measure for the axis. For a continuous angular axis such as longitude, the values wrap-around at this value. Also, values beyond this minimum/maximum can be used for specified purposes, such as in a bounding box. A value of minus infinity shall be allowed for the gml:minimumValue element, a value of plus infiniy for the gml:maximumValue element. If these elements are omitted, the value is unspecified.')

    
    # Element {http://www.opengis.net/gml/3.2}maximumValue uses Python identifier maximumValue
    __maximumValue = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'maximumValue'), 'maximumValue', '__httpwww_opengis_netgml3_2_CoordinateSystemAxisType_httpwww_opengis_netgml3_2maximumValue', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateSystems.xsd', 59, 1), )

    
    maximumValue = property(__maximumValue.value, __maximumValue.set, None, 'The gml:minimumValue and gml:maximumValue properties allow the specification of minimum and maximum value normally allowed for this axis, in the unit of measure for the axis. For a continuous angular axis such as longitude, the values wrap-around at this value. Also, values beyond this minimum/maximum can be used for specified purposes, such as in a bounding box. A value of minus infinity shall be allowed for the gml:minimumValue element, a value of plus infiniy for the gml:maximumValue element. If these elements are omitted, the value is unspecified.')

    
    # Element {http://www.opengis.net/gml/3.2}rangeMeaning uses Python identifier rangeMeaning
    __rangeMeaning = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'rangeMeaning'), 'rangeMeaning', '__httpwww_opengis_netgml3_2_CoordinateSystemAxisType_httpwww_opengis_netgml3_2rangeMeaning', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateSystems.xsd', 64, 1), )

    
    rangeMeaning = property(__rangeMeaning.value, __rangeMeaning.set, None, 'gml:rangeMeaning describes the meaning of axis value range specified by gml:minimumValue and gml:maximumValue. This element shall be omitted when both gml:minimumValue and gml:maximumValue are omitted. This element should be included when gml:minimumValue and/or gml:maximumValue are included. If this element is omitted when the gml:minimumValue and/or gml:maximumValue are included, the meaning is unspecified. The codeSpace attribute shall reference a source of information specifying the values and meanings of all the allowed string values for this property.')

    
    # Element metaDataProperty ({http://www.opengis.net/gml/3.2}metaDataProperty) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element remarks ({http://www.opengis.net/gml/3.2}remarks) inherited from {http://www.opengis.net/gml/3.2}DefinitionType
    
    # Element description ({http://www.opengis.net/gml/3.2}description) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element descriptionReference ({http://www.opengis.net/gml/3.2}descriptionReference) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element name ({http://www.opengis.net/gml/3.2}name) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element identifier ({http://www.opengis.net/gml/3.2}identifier) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Attribute uom uses Python identifier uom
    __uom = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'uom'), 'uom', '__httpwww_opengis_netgml3_2_CoordinateSystemAxisType_uom', _module_typeBindings.UomIdentifier, required=True)
    __uom._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateSystems.xsd', 34, 4)
    __uom._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateSystems.xsd', 34, 4)
    
    uom = property(__uom.value, __uom.set, None, 'The uom attribute provides an identifier of the unit of measure used for this coordinate system axis. The value of this coordinate in a coordinate tuple shall be recorded using this unit of measure, whenever those coordinates use a coordinate reference system that uses a coordinate system that uses this axis.')

    
    # Attribute id_ inherited from {http://www.opengis.net/gml/3.2}DefinitionBaseType
    _ElementMap.update({
        __axisAbbrev.name() : __axisAbbrev,
        __axisDirection.name() : __axisDirection,
        __minimumValue.name() : __minimumValue,
        __maximumValue.name() : __maximumValue,
        __rangeMeaning.name() : __rangeMeaning
    })
    _AttributeMap.update({
        __uom.name() : __uom
    })
_module_typeBindings.CoordinateSystemAxisType = CoordinateSystemAxisType
_Namespace_gml.addCategoryObject('typeBinding', 'CoordinateSystemAxisType', CoordinateSystemAxisType)


# Complex type {http://www.opengis.net/gml/3.2}AbstractCoordinateSystemType with content type ELEMENT_ONLY
class AbstractCoordinateSystemType (IdentifiedObjectType):
    """Complex type {http://www.opengis.net/gml/3.2}AbstractCoordinateSystemType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = True
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractCoordinateSystemType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateSystems.xsd', 83, 1)
    _ElementMap = IdentifiedObjectType._ElementMap.copy()
    _AttributeMap = IdentifiedObjectType._AttributeMap.copy()
    # Base type is IdentifiedObjectType
    
    # Element {http://www.opengis.net/gml/3.2}axis uses Python identifier axis
    __axis = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'axis'), 'axis', '__httpwww_opengis_netgml3_2_AbstractCoordinateSystemType_httpwww_opengis_netgml3_2axis', True, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateSystems.xsd', 93, 1), )

    
    axis = property(__axis.value, __axis.set, None, 'The gml:axis property is an association role (ordered sequence) to the coordinate system axes included in this coordinate system. The coordinate values in a coordinate tuple shall be recorded in the order in which the coordinate system axes associations are recorded, whenever those coordinates use a coordinate reference system that uses this coordinate system. The gml:AggregationAttributeGroup should be used to specify that the axis objects are ordered.')

    
    # Element metaDataProperty ({http://www.opengis.net/gml/3.2}metaDataProperty) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element remarks ({http://www.opengis.net/gml/3.2}remarks) inherited from {http://www.opengis.net/gml/3.2}DefinitionType
    
    # Element description ({http://www.opengis.net/gml/3.2}description) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element descriptionReference ({http://www.opengis.net/gml/3.2}descriptionReference) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element name ({http://www.opengis.net/gml/3.2}name) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element identifier ({http://www.opengis.net/gml/3.2}identifier) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Attribute id_ inherited from {http://www.opengis.net/gml/3.2}DefinitionBaseType
    
    # Attribute aggregationType uses Python identifier aggregationType
    __aggregationType = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'aggregationType'), 'aggregationType', '__httpwww_opengis_netgml3_2_AbstractCoordinateSystemType_aggregationType', _module_typeBindings.AggregationType)
    __aggregationType._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 158, 2)
    __aggregationType._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 158, 2)
    
    aggregationType = property(__aggregationType.value, __aggregationType.set, None, None)

    _ElementMap.update({
        __axis.name() : __axis
    })
    _AttributeMap.update({
        __aggregationType.name() : __aggregationType
    })
_module_typeBindings.AbstractCoordinateSystemType = AbstractCoordinateSystemType
_Namespace_gml.addCategoryObject('typeBinding', 'AbstractCoordinateSystemType', AbstractCoordinateSystemType)


# Complex type {http://www.opengis.net/gml/3.2}AbstractDatumType with content type ELEMENT_ONLY
class AbstractDatumType (IdentifiedObjectType):
    """Complex type {http://www.opengis.net/gml/3.2}AbstractDatumType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = True
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractDatumType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/datums.xsd', 26, 1)
    _ElementMap = IdentifiedObjectType._ElementMap.copy()
    _AttributeMap = IdentifiedObjectType._AttributeMap.copy()
    # Base type is IdentifiedObjectType
    
    # Element {http://www.opengis.net/gml/3.2}anchorDefinition uses Python identifier anchorDefinition
    __anchorDefinition = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'anchorDefinition'), 'anchorDefinition', '__httpwww_opengis_netgml3_2_AbstractDatumType_httpwww_opengis_netgml3_2anchorDefinition', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/datums.xsd', 38, 1), )

    
    anchorDefinition = property(__anchorDefinition.value, __anchorDefinition.set, None, 'gml:anchorDefinition is a description, possibly including coordinates, of the definition used to anchor the datum to the Earth. Also known as the "origin", especially for engineering and image datums. The codeSpace attribute may be used to reference a source of more detailed on this point or surface, or on a set of such descriptions.\n-\tFor a geodetic datum, this point is also known as the fundamental point, which is traditionally the point where the relationship between geoid and ellipsoid is defined. In some cases, the "fundamental point" may consist of a number of points. In those cases, the parameters defining the geoid/ellipsoid relationship have been averaged for these points, and the averages adopted as the datum definition.\n-\tFor an engineering datum, the anchor definition may be a physical point, or it may be a point with defined coordinates in another CRS.may\n-\tFor an image datum, the anchor definition is usually either the centre of the image or the corner of the image.\n-\tFor a temporal datum, this attribute is not defined. Instead of the anchor definition, a temporal datum carries a separate time origin of type DateTime.')

    
    # Element {http://www.opengis.net/gml/3.2}realizationEpoch uses Python identifier realizationEpoch
    __realizationEpoch = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'realizationEpoch'), 'realizationEpoch', '__httpwww_opengis_netgml3_2_AbstractDatumType_httpwww_opengis_netgml3_2realizationEpoch', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/datums.xsd', 47, 1), )

    
    realizationEpoch = property(__realizationEpoch.value, __realizationEpoch.set, None, 'gml:realizationEpoch is the time after which this datum definition is valid. See ISO 19111 Table 32 for details.')

    
    # Element metaDataProperty ({http://www.opengis.net/gml/3.2}metaDataProperty) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element remarks ({http://www.opengis.net/gml/3.2}remarks) inherited from {http://www.opengis.net/gml/3.2}DefinitionType
    
    # Element description ({http://www.opengis.net/gml/3.2}description) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element descriptionReference ({http://www.opengis.net/gml/3.2}descriptionReference) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element name ({http://www.opengis.net/gml/3.2}name) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element identifier ({http://www.opengis.net/gml/3.2}identifier) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element {http://www.opengis.net/gml/3.2}domainOfValidity uses Python identifier domainOfValidity
    __domainOfValidity = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'domainOfValidity'), 'domainOfValidity', '__httpwww_opengis_netgml3_2_AbstractDatumType_httpwww_opengis_netgml3_2domainOfValidity', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/referenceSystems.xsd', 45, 1), )

    
    domainOfValidity = property(__domainOfValidity.value, __domainOfValidity.set, None, 'The gml:domainOfValidity property implements an association role to an EX_Extent object as encoded in ISO/TS 19139, either referencing or containing the definition of that extent.')

    
    # Element {http://www.opengis.net/gml/3.2}scope uses Python identifier scope
    __scope = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'scope'), 'scope', '__httpwww_opengis_netgml3_2_AbstractDatumType_httpwww_opengis_netgml3_2scope', True, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/referenceSystems.xsd', 56, 1), )

    
    scope = property(__scope.value, __scope.set, None, 'The gml:scope property provides a description of the usage, or limitations of usage, for which this CRS-related object is valid. If unknown, enter "not known".')

    
    # Attribute id_ inherited from {http://www.opengis.net/gml/3.2}DefinitionBaseType
    _ElementMap.update({
        __anchorDefinition.name() : __anchorDefinition,
        __realizationEpoch.name() : __realizationEpoch,
        __domainOfValidity.name() : __domainOfValidity,
        __scope.name() : __scope
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.AbstractDatumType = AbstractDatumType
_Namespace_gml.addCategoryObject('typeBinding', 'AbstractDatumType', AbstractDatumType)


# Complex type {http://www.opengis.net/gml/3.2}EllipsoidType with content type ELEMENT_ONLY
class EllipsoidType (IdentifiedObjectType):
    """Complex type {http://www.opengis.net/gml/3.2}EllipsoidType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'EllipsoidType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/datums.xsd', 100, 1)
    _ElementMap = IdentifiedObjectType._ElementMap.copy()
    _AttributeMap = IdentifiedObjectType._AttributeMap.copy()
    # Base type is IdentifiedObjectType
    
    # Element {http://www.opengis.net/gml/3.2}semiMajorAxis uses Python identifier semiMajorAxis
    __semiMajorAxis = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'semiMajorAxis'), 'semiMajorAxis', '__httpwww_opengis_netgml3_2_EllipsoidType_httpwww_opengis_netgml3_2semiMajorAxis', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/datums.xsd', 110, 1), )

    
    semiMajorAxis = property(__semiMajorAxis.value, __semiMajorAxis.set, None, 'gml:semiMajorAxis specifies the length of the semi-major axis of the ellipsoid, with its units. Uses the MeasureType with the restriction that the unit of measure referenced by uom must be suitable for a length, such as metres or feet.')

    
    # Element {http://www.opengis.net/gml/3.2}secondDefiningParameter uses Python identifier secondDefiningParameter
    __secondDefiningParameter = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'secondDefiningParameter'), 'secondDefiningParameter', '__httpwww_opengis_netgml3_2_EllipsoidType_httpwww_opengis_netgml3_2secondDefiningParameter', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/datums.xsd', 115, 1), )

    
    secondDefiningParameter = property(__secondDefiningParameter.value, __secondDefiningParameter.set, None, 'gml:secondDefiningParameter is a property containing the definition of the second parameter that defines the shape of an ellipsoid. An ellipsoid requires two defining parameters: semi-major axis and inverse flattening or semi-major axis and semi-minor axis. When the reference body is a sphere rather than an ellipsoid, only a single defining parameter is required, namely the radius of the sphere; in that case, the semi-major axis "degenerates" into the radius of the sphere.\nThe inverseFlattening element contains the inverse flattening value of the ellipsoid. This value is a scale factor (or ratio). It uses gml:LengthType with the restriction that the unit of measure referenced by the uom attribute must be suitable for a scale factor, such as percent, permil, or parts-per-million.\nThe semiMinorAxis element contains the length of the semi-minor axis of the ellipsoid. When the isSphere element is included, the ellipsoid is degenerate and is actually a sphere. The sphere is completely defined by the semi-major axis, which is the radius of the sphere.')

    
    # Element metaDataProperty ({http://www.opengis.net/gml/3.2}metaDataProperty) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element remarks ({http://www.opengis.net/gml/3.2}remarks) inherited from {http://www.opengis.net/gml/3.2}DefinitionType
    
    # Element description ({http://www.opengis.net/gml/3.2}description) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element descriptionReference ({http://www.opengis.net/gml/3.2}descriptionReference) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element name ({http://www.opengis.net/gml/3.2}name) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element identifier ({http://www.opengis.net/gml/3.2}identifier) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Attribute id_ inherited from {http://www.opengis.net/gml/3.2}DefinitionBaseType
    _ElementMap.update({
        __semiMajorAxis.name() : __semiMajorAxis,
        __secondDefiningParameter.name() : __secondDefiningParameter
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.EllipsoidType = EllipsoidType
_Namespace_gml.addCategoryObject('typeBinding', 'EllipsoidType', EllipsoidType)


# Complex type {http://www.opengis.net/gml/3.2}PrimeMeridianType with content type ELEMENT_ONLY
class PrimeMeridianType (IdentifiedObjectType):
    """Complex type {http://www.opengis.net/gml/3.2}PrimeMeridianType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'PrimeMeridianType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/datums.xsd', 150, 1)
    _ElementMap = IdentifiedObjectType._ElementMap.copy()
    _AttributeMap = IdentifiedObjectType._AttributeMap.copy()
    # Base type is IdentifiedObjectType
    
    # Element {http://www.opengis.net/gml/3.2}greenwichLongitude uses Python identifier greenwichLongitude
    __greenwichLongitude = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'greenwichLongitude'), 'greenwichLongitude', '__httpwww_opengis_netgml3_2_PrimeMeridianType_httpwww_opengis_netgml3_2greenwichLongitude', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/datums.xsd', 159, 1), )

    
    greenwichLongitude = property(__greenwichLongitude.value, __greenwichLongitude.set, None, 'gml:greenwichLongitude is the longitude of the prime meridian measured from the Greenwich meridian, positive eastward. If the value of the prime meridian "name" is "Greenwich" then the value of greenwichLongitude shall be 0 degrees.')

    
    # Element metaDataProperty ({http://www.opengis.net/gml/3.2}metaDataProperty) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element remarks ({http://www.opengis.net/gml/3.2}remarks) inherited from {http://www.opengis.net/gml/3.2}DefinitionType
    
    # Element description ({http://www.opengis.net/gml/3.2}description) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element descriptionReference ({http://www.opengis.net/gml/3.2}descriptionReference) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element name ({http://www.opengis.net/gml/3.2}name) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element identifier ({http://www.opengis.net/gml/3.2}identifier) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Attribute id_ inherited from {http://www.opengis.net/gml/3.2}DefinitionBaseType
    _ElementMap.update({
        __greenwichLongitude.name() : __greenwichLongitude
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.PrimeMeridianType = PrimeMeridianType
_Namespace_gml.addCategoryObject('typeBinding', 'PrimeMeridianType', PrimeMeridianType)


# Complex type {http://www.opengis.net/gml/3.2}LineStringType with content type ELEMENT_ONLY
class LineStringType (AbstractCurveType):
    """Complex type {http://www.opengis.net/gml/3.2}LineStringType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'LineStringType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic0d1d.xsd', 255, 1)
    _ElementMap = AbstractCurveType._ElementMap.copy()
    _AttributeMap = AbstractCurveType._AttributeMap.copy()
    # Base type is AbstractCurveType
    
    # Element metaDataProperty ({http://www.opengis.net/gml/3.2}metaDataProperty) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element {http://www.opengis.net/gml/3.2}coordinates uses Python identifier coordinates
    __coordinates = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'coordinates'), 'coordinates', '__httpwww_opengis_netgml3_2_LineStringType_httpwww_opengis_netgml3_2coordinates', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 751, 1), )

    
    coordinates = property(__coordinates.value, __coordinates.set, None, '')

    
    # Element {http://www.opengis.net/gml/3.2}pointRep uses Python identifier pointRep
    __pointRep = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'pointRep'), 'pointRep', '__httpwww_opengis_netgml3_2_LineStringType_httpwww_opengis_netgml3_2pointRep', True, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 756, 1), )

    
    pointRep = property(__pointRep.value, __pointRep.set, None, '')

    
    # Element {http://www.opengis.net/gml/3.2}pos uses Python identifier pos
    __pos = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'pos'), 'pos', '__httpwww_opengis_netgml3_2_LineStringType_httpwww_opengis_netgml3_2pos', True, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic0d1d.xsd', 87, 1), )

    
    pos = property(__pos.value, __pos.set, None, None)

    
    # Element {http://www.opengis.net/gml/3.2}posList uses Python identifier posList
    __posList = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'posList'), 'posList', '__httpwww_opengis_netgml3_2_LineStringType_httpwww_opengis_netgml3_2posList', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic0d1d.xsd', 102, 1), )

    
    posList = property(__posList.value, __posList.set, None, None)

    
    # Element {http://www.opengis.net/gml/3.2}pointProperty uses Python identifier pointProperty
    __pointProperty = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'pointProperty'), 'pointProperty', '__httpwww_opengis_netgml3_2_LineStringType_httpwww_opengis_netgml3_2pointProperty', True, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic0d1d.xsd', 204, 1), )

    
    pointProperty = property(__pointProperty.value, __pointProperty.set, None, 'This property element either references a point via the XLink-attributes or contains the point element. pointProperty is the predefined property which may be used by GML Application Schemas whenever a GML feature has a property with a value that is substitutable for Point.')

    
    # Element description ({http://www.opengis.net/gml/3.2}description) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element descriptionReference ({http://www.opengis.net/gml/3.2}descriptionReference) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element name ({http://www.opengis.net/gml/3.2}name) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element identifier ({http://www.opengis.net/gml/3.2}identifier) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Attribute srsName inherited from {http://www.opengis.net/gml/3.2}AbstractGeometryType
    
    # Attribute srsDimension inherited from {http://www.opengis.net/gml/3.2}AbstractGeometryType
    
    # Attribute axisLabels inherited from {http://www.opengis.net/gml/3.2}AbstractGeometryType
    
    # Attribute uomLabels inherited from {http://www.opengis.net/gml/3.2}AbstractGeometryType
    
    # Attribute id inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    _ElementMap.update({
        __coordinates.name() : __coordinates,
        __pointRep.name() : __pointRep,
        __pos.name() : __pos,
        __posList.name() : __posList,
        __pointProperty.name() : __pointProperty
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.LineStringType = LineStringType
_Namespace_gml.addCategoryObject('typeBinding', 'LineStringType', LineStringType)


# Complex type {http://www.opengis.net/gml/3.2}PolygonType with content type ELEMENT_ONLY
class PolygonType (AbstractSurfaceType):
    """Complex type {http://www.opengis.net/gml/3.2}PolygonType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'PolygonType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic2d.xsd', 51, 1)
    _ElementMap = AbstractSurfaceType._ElementMap.copy()
    _AttributeMap = AbstractSurfaceType._AttributeMap.copy()
    # Base type is AbstractSurfaceType
    
    # Element metaDataProperty ({http://www.opengis.net/gml/3.2}metaDataProperty) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element {http://www.opengis.net/gml/3.2}exterior uses Python identifier exterior
    __exterior = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'exterior'), 'exterior', '__httpwww_opengis_netgml3_2_PolygonType_httpwww_opengis_netgml3_2exterior', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic2d.xsd', 67, 1), )

    
    exterior = property(__exterior.value, __exterior.set, None, 'A boundary of a surface consists of a number of rings. In the normal 2D case, one of these rings is distinguished as being the exterior boundary. In a general manifold this is not always possible, in which case all boundaries shall be listed as interior boundaries, and the exterior will be empty.')

    
    # Element {http://www.opengis.net/gml/3.2}interior uses Python identifier interior
    __interior = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'interior'), 'interior', '__httpwww_opengis_netgml3_2_PolygonType_httpwww_opengis_netgml3_2interior', True, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic2d.xsd', 72, 1), )

    
    interior = property(__interior.value, __interior.set, None, 'A boundary of a surface consists of a number of rings. The "interior" rings separate the surface / surface patch from the area enclosed by the rings.')

    
    # Element description ({http://www.opengis.net/gml/3.2}description) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element descriptionReference ({http://www.opengis.net/gml/3.2}descriptionReference) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element name ({http://www.opengis.net/gml/3.2}name) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element identifier ({http://www.opengis.net/gml/3.2}identifier) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Attribute srsName inherited from {http://www.opengis.net/gml/3.2}AbstractGeometryType
    
    # Attribute srsDimension inherited from {http://www.opengis.net/gml/3.2}AbstractGeometryType
    
    # Attribute axisLabels inherited from {http://www.opengis.net/gml/3.2}AbstractGeometryType
    
    # Attribute uomLabels inherited from {http://www.opengis.net/gml/3.2}AbstractGeometryType
    
    # Attribute id inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    _ElementMap.update({
        __exterior.name() : __exterior,
        __interior.name() : __interior
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.PolygonType = PolygonType
_Namespace_gml.addCategoryObject('typeBinding', 'PolygonType', PolygonType)


# Complex type {http://www.opengis.net/gml/3.2}AbstractRingType with content type ELEMENT_ONLY
class AbstractRingType (AbstractCurveType):
    """Complex type {http://www.opengis.net/gml/3.2}AbstractRingType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = True
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractRingType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic2d.xsd', 77, 1)
    _ElementMap = AbstractCurveType._ElementMap.copy()
    _AttributeMap = AbstractCurveType._AttributeMap.copy()
    # Base type is AbstractCurveType
    
    # Element metaDataProperty ({http://www.opengis.net/gml/3.2}metaDataProperty) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element description ({http://www.opengis.net/gml/3.2}description) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element descriptionReference ({http://www.opengis.net/gml/3.2}descriptionReference) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element name ({http://www.opengis.net/gml/3.2}name) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element identifier ({http://www.opengis.net/gml/3.2}identifier) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Attribute srsName inherited from {http://www.opengis.net/gml/3.2}AbstractGeometryType
    
    # Attribute srsDimension inherited from {http://www.opengis.net/gml/3.2}AbstractGeometryType
    
    # Attribute axisLabels inherited from {http://www.opengis.net/gml/3.2}AbstractGeometryType
    
    # Attribute uomLabels inherited from {http://www.opengis.net/gml/3.2}AbstractGeometryType
    
    # Attribute id inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    _ElementMap.update({
        
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.AbstractRingType = AbstractRingType
_Namespace_gml.addCategoryObject('typeBinding', 'AbstractRingType', AbstractRingType)


# Complex type {http://www.opengis.net/gml/3.2}CompositeCurveType with content type ELEMENT_ONLY
class CompositeCurveType (AbstractCurveType):
    """Complex type {http://www.opengis.net/gml/3.2}CompositeCurveType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'CompositeCurveType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryComplexes.xsd', 44, 1)
    _ElementMap = AbstractCurveType._ElementMap.copy()
    _AttributeMap = AbstractCurveType._AttributeMap.copy()
    # Base type is AbstractCurveType
    
    # Element metaDataProperty ({http://www.opengis.net/gml/3.2}metaDataProperty) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element {http://www.opengis.net/gml/3.2}curveMember uses Python identifier curveMember
    __curveMember = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'curveMember'), 'curveMember', '__httpwww_opengis_netgml3_2_CompositeCurveType_httpwww_opengis_netgml3_2curveMember', True, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 639, 1), )

    
    curveMember = property(__curveMember.value, __curveMember.set, None, None)

    
    # Element description ({http://www.opengis.net/gml/3.2}description) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element descriptionReference ({http://www.opengis.net/gml/3.2}descriptionReference) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element name ({http://www.opengis.net/gml/3.2}name) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element identifier ({http://www.opengis.net/gml/3.2}identifier) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Attribute srsName inherited from {http://www.opengis.net/gml/3.2}AbstractGeometryType
    
    # Attribute srsDimension inherited from {http://www.opengis.net/gml/3.2}AbstractGeometryType
    
    # Attribute axisLabels inherited from {http://www.opengis.net/gml/3.2}AbstractGeometryType
    
    # Attribute uomLabels inherited from {http://www.opengis.net/gml/3.2}AbstractGeometryType
    
    # Attribute id inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Attribute aggregationType uses Python identifier aggregationType
    __aggregationType = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'aggregationType'), 'aggregationType', '__httpwww_opengis_netgml3_2_CompositeCurveType_aggregationType', _module_typeBindings.AggregationType)
    __aggregationType._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 158, 2)
    __aggregationType._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 158, 2)
    
    aggregationType = property(__aggregationType.value, __aggregationType.set, None, None)

    _ElementMap.update({
        __curveMember.name() : __curveMember
    })
    _AttributeMap.update({
        __aggregationType.name() : __aggregationType
    })
_module_typeBindings.CompositeCurveType = CompositeCurveType
_Namespace_gml.addCategoryObject('typeBinding', 'CompositeCurveType', CompositeCurveType)


# Complex type {http://www.opengis.net/gml/3.2}CompositeSurfaceType with content type ELEMENT_ONLY
class CompositeSurfaceType (AbstractSurfaceType):
    """Complex type {http://www.opengis.net/gml/3.2}CompositeSurfaceType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'CompositeSurfaceType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryComplexes.xsd', 61, 1)
    _ElementMap = AbstractSurfaceType._ElementMap.copy()
    _AttributeMap = AbstractSurfaceType._AttributeMap.copy()
    # Base type is AbstractSurfaceType
    
    # Element metaDataProperty ({http://www.opengis.net/gml/3.2}metaDataProperty) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element {http://www.opengis.net/gml/3.2}surfaceMember uses Python identifier surfaceMember
    __surfaceMember = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'surfaceMember'), 'surfaceMember', '__httpwww_opengis_netgml3_2_CompositeSurfaceType_httpwww_opengis_netgml3_2surfaceMember', True, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 837, 1), )

    
    surfaceMember = property(__surfaceMember.value, __surfaceMember.set, None, 'This property element either references a surface via the XLink-attributes or contains the surface element. A surface element is any element, which is substitutable for gml:AbstractSurface.')

    
    # Element description ({http://www.opengis.net/gml/3.2}description) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element descriptionReference ({http://www.opengis.net/gml/3.2}descriptionReference) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element name ({http://www.opengis.net/gml/3.2}name) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element identifier ({http://www.opengis.net/gml/3.2}identifier) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Attribute srsName inherited from {http://www.opengis.net/gml/3.2}AbstractGeometryType
    
    # Attribute srsDimension inherited from {http://www.opengis.net/gml/3.2}AbstractGeometryType
    
    # Attribute axisLabels inherited from {http://www.opengis.net/gml/3.2}AbstractGeometryType
    
    # Attribute uomLabels inherited from {http://www.opengis.net/gml/3.2}AbstractGeometryType
    
    # Attribute id inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Attribute aggregationType uses Python identifier aggregationType
    __aggregationType = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'aggregationType'), 'aggregationType', '__httpwww_opengis_netgml3_2_CompositeSurfaceType_aggregationType', _module_typeBindings.AggregationType)
    __aggregationType._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 158, 2)
    __aggregationType._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 158, 2)
    
    aggregationType = property(__aggregationType.value, __aggregationType.set, None, None)

    _ElementMap.update({
        __surfaceMember.name() : __surfaceMember
    })
    _AttributeMap.update({
        __aggregationType.name() : __aggregationType
    })
_module_typeBindings.CompositeSurfaceType = CompositeSurfaceType
_Namespace_gml.addCategoryObject('typeBinding', 'CompositeSurfaceType', CompositeSurfaceType)


# Complex type {http://www.opengis.net/gml/3.2}CompositeSolidType with content type ELEMENT_ONLY
class CompositeSolidType (AbstractSolidType):
    """Complex type {http://www.opengis.net/gml/3.2}CompositeSolidType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'CompositeSolidType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryComplexes.xsd', 78, 1)
    _ElementMap = AbstractSolidType._ElementMap.copy()
    _AttributeMap = AbstractSolidType._AttributeMap.copy()
    # Base type is AbstractSolidType
    
    # Element metaDataProperty ({http://www.opengis.net/gml/3.2}metaDataProperty) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element {http://www.opengis.net/gml/3.2}solidMember uses Python identifier solidMember
    __solidMember = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'solidMember'), 'solidMember', '__httpwww_opengis_netgml3_2_CompositeSolidType_httpwww_opengis_netgml3_2solidMember', True, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryAggregates.xsd', 177, 1), )

    
    solidMember = property(__solidMember.value, __solidMember.set, None, 'This property element either references a solid via the XLink-attributes or contains the solid element. A solid element is any element, which is substitutable for gml:AbstractSolid.')

    
    # Element description ({http://www.opengis.net/gml/3.2}description) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element descriptionReference ({http://www.opengis.net/gml/3.2}descriptionReference) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element name ({http://www.opengis.net/gml/3.2}name) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element identifier ({http://www.opengis.net/gml/3.2}identifier) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Attribute srsName inherited from {http://www.opengis.net/gml/3.2}AbstractGeometryType
    
    # Attribute srsDimension inherited from {http://www.opengis.net/gml/3.2}AbstractGeometryType
    
    # Attribute axisLabels inherited from {http://www.opengis.net/gml/3.2}AbstractGeometryType
    
    # Attribute uomLabels inherited from {http://www.opengis.net/gml/3.2}AbstractGeometryType
    
    # Attribute id inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Attribute aggregationType uses Python identifier aggregationType
    __aggregationType = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'aggregationType'), 'aggregationType', '__httpwww_opengis_netgml3_2_CompositeSolidType_aggregationType', _module_typeBindings.AggregationType)
    __aggregationType._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 158, 2)
    __aggregationType._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 158, 2)
    
    aggregationType = property(__aggregationType.value, __aggregationType.set, None, None)

    _ElementMap.update({
        __solidMember.name() : __solidMember
    })
    _AttributeMap.update({
        __aggregationType.name() : __aggregationType
    })
_module_typeBindings.CompositeSolidType = CompositeSolidType
_Namespace_gml.addCategoryObject('typeBinding', 'CompositeSolidType', CompositeSolidType)


# Complex type {http://www.opengis.net/gml/3.2}CurveType with content type ELEMENT_ONLY
class CurveType (AbstractCurveType):
    """Complex type {http://www.opengis.net/gml/3.2}CurveType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'CurveType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 15, 1)
    _ElementMap = AbstractCurveType._ElementMap.copy()
    _AttributeMap = AbstractCurveType._AttributeMap.copy()
    # Base type is AbstractCurveType
    
    # Element metaDataProperty ({http://www.opengis.net/gml/3.2}metaDataProperty) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element {http://www.opengis.net/gml/3.2}segments uses Python identifier segments
    __segments = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'segments'), 'segments', '__httpwww_opengis_netgml3_2_CurveType_httpwww_opengis_netgml3_2segments', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 73, 1), )

    
    segments = property(__segments.value, __segments.set, None, 'This property element contains a list of curve segments. The order of the elements is significant and shall be preserved when processing the array.')

    
    # Element description ({http://www.opengis.net/gml/3.2}description) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element descriptionReference ({http://www.opengis.net/gml/3.2}descriptionReference) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element name ({http://www.opengis.net/gml/3.2}name) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element identifier ({http://www.opengis.net/gml/3.2}identifier) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Attribute srsName inherited from {http://www.opengis.net/gml/3.2}AbstractGeometryType
    
    # Attribute srsDimension inherited from {http://www.opengis.net/gml/3.2}AbstractGeometryType
    
    # Attribute axisLabels inherited from {http://www.opengis.net/gml/3.2}AbstractGeometryType
    
    # Attribute uomLabels inherited from {http://www.opengis.net/gml/3.2}AbstractGeometryType
    
    # Attribute id inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    _ElementMap.update({
        __segments.name() : __segments
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.CurveType = CurveType
_Namespace_gml.addCategoryObject('typeBinding', 'CurveType', CurveType)


# Complex type {http://www.opengis.net/gml/3.2}OrientableCurveType with content type ELEMENT_ONLY
class OrientableCurveType (AbstractCurveType):
    """Complex type {http://www.opengis.net/gml/3.2}OrientableCurveType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'OrientableCurveType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 32, 1)
    _ElementMap = AbstractCurveType._ElementMap.copy()
    _AttributeMap = AbstractCurveType._AttributeMap.copy()
    # Base type is AbstractCurveType
    
    # Element metaDataProperty ({http://www.opengis.net/gml/3.2}metaDataProperty) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element {http://www.opengis.net/gml/3.2}baseCurve uses Python identifier baseCurve
    __baseCurve = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'baseCurve'), 'baseCurve', '__httpwww_opengis_netgml3_2_OrientableCurveType_httpwww_opengis_netgml3_2baseCurve', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 42, 1), )

    
    baseCurve = property(__baseCurve.value, __baseCurve.set, None, 'The property baseCurve references or contains the base curve, i.e. it either references the base curve via the XLink-attributes or contains the curve element. A curve element is any element which is substitutable for AbstractCurve. The base curve has positive orientation.')

    
    # Element description ({http://www.opengis.net/gml/3.2}description) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element descriptionReference ({http://www.opengis.net/gml/3.2}descriptionReference) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element name ({http://www.opengis.net/gml/3.2}name) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element identifier ({http://www.opengis.net/gml/3.2}identifier) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Attribute srsName inherited from {http://www.opengis.net/gml/3.2}AbstractGeometryType
    
    # Attribute srsDimension inherited from {http://www.opengis.net/gml/3.2}AbstractGeometryType
    
    # Attribute axisLabels inherited from {http://www.opengis.net/gml/3.2}AbstractGeometryType
    
    # Attribute uomLabels inherited from {http://www.opengis.net/gml/3.2}AbstractGeometryType
    
    # Attribute orientation uses Python identifier orientation
    __orientation = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'orientation'), 'orientation', '__httpwww_opengis_netgml3_2_OrientableCurveType_orientation', _module_typeBindings.SignType, unicode_default='+')
    __orientation._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 38, 4)
    __orientation._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 38, 4)
    
    orientation = property(__orientation.value, __orientation.set, None, None)

    
    # Attribute id inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    _ElementMap.update({
        __baseCurve.name() : __baseCurve
    })
    _AttributeMap.update({
        __orientation.name() : __orientation
    })
_module_typeBindings.OrientableCurveType = OrientableCurveType
_Namespace_gml.addCategoryObject('typeBinding', 'OrientableCurveType', OrientableCurveType)


# Complex type {http://www.opengis.net/gml/3.2}SurfaceType with content type ELEMENT_ONLY
class SurfaceType (AbstractSurfaceType):
    """Complex type {http://www.opengis.net/gml/3.2}SurfaceType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'SurfaceType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 498, 1)
    _ElementMap = AbstractSurfaceType._ElementMap.copy()
    _AttributeMap = AbstractSurfaceType._AttributeMap.copy()
    # Base type is AbstractSurfaceType
    
    # Element metaDataProperty ({http://www.opengis.net/gml/3.2}metaDataProperty) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element {http://www.opengis.net/gml/3.2}patches uses Python identifier patches
    __patches = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'patches'), 'patches', '__httpwww_opengis_netgml3_2_SurfaceType_httpwww_opengis_netgml3_2patches', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 549, 1), )

    
    patches = property(__patches.value, __patches.set, None, 'The patches property element contains the sequence of surface patches. The order of the elements is significant and shall be preserved when processing the array.')

    
    # Element description ({http://www.opengis.net/gml/3.2}description) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element descriptionReference ({http://www.opengis.net/gml/3.2}descriptionReference) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element name ({http://www.opengis.net/gml/3.2}name) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element identifier ({http://www.opengis.net/gml/3.2}identifier) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Attribute srsName inherited from {http://www.opengis.net/gml/3.2}AbstractGeometryType
    
    # Attribute srsDimension inherited from {http://www.opengis.net/gml/3.2}AbstractGeometryType
    
    # Attribute axisLabels inherited from {http://www.opengis.net/gml/3.2}AbstractGeometryType
    
    # Attribute uomLabels inherited from {http://www.opengis.net/gml/3.2}AbstractGeometryType
    
    # Attribute id inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    _ElementMap.update({
        __patches.name() : __patches
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.SurfaceType = SurfaceType
_Namespace_gml.addCategoryObject('typeBinding', 'SurfaceType', SurfaceType)


# Complex type {http://www.opengis.net/gml/3.2}OrientableSurfaceType with content type ELEMENT_ONLY
class OrientableSurfaceType (AbstractSurfaceType):
    """Complex type {http://www.opengis.net/gml/3.2}OrientableSurfaceType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'OrientableSurfaceType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 513, 1)
    _ElementMap = AbstractSurfaceType._ElementMap.copy()
    _AttributeMap = AbstractSurfaceType._AttributeMap.copy()
    # Base type is AbstractSurfaceType
    
    # Element metaDataProperty ({http://www.opengis.net/gml/3.2}metaDataProperty) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element {http://www.opengis.net/gml/3.2}baseSurface uses Python identifier baseSurface
    __baseSurface = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'baseSurface'), 'baseSurface', '__httpwww_opengis_netgml3_2_OrientableSurfaceType_httpwww_opengis_netgml3_2baseSurface', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 523, 1), )

    
    baseSurface = property(__baseSurface.value, __baseSurface.set, None, 'The property baseSurface references or contains the base surface. The property baseSurface either references the base surface via the XLink-attributes or contains the surface element. A surface element is any element which is substitutable for gml:AbstractSurface. The base surface has positive orientation.')

    
    # Element description ({http://www.opengis.net/gml/3.2}description) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element descriptionReference ({http://www.opengis.net/gml/3.2}descriptionReference) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element name ({http://www.opengis.net/gml/3.2}name) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element identifier ({http://www.opengis.net/gml/3.2}identifier) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Attribute srsName inherited from {http://www.opengis.net/gml/3.2}AbstractGeometryType
    
    # Attribute srsDimension inherited from {http://www.opengis.net/gml/3.2}AbstractGeometryType
    
    # Attribute axisLabels inherited from {http://www.opengis.net/gml/3.2}AbstractGeometryType
    
    # Attribute uomLabels inherited from {http://www.opengis.net/gml/3.2}AbstractGeometryType
    
    # Attribute orientation uses Python identifier orientation
    __orientation = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'orientation'), 'orientation', '__httpwww_opengis_netgml3_2_OrientableSurfaceType_orientation', _module_typeBindings.SignType, unicode_default='+')
    __orientation._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 519, 4)
    __orientation._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 519, 4)
    
    orientation = property(__orientation.value, __orientation.set, None, None)

    
    # Attribute id inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    _ElementMap.update({
        __baseSurface.name() : __baseSurface
    })
    _AttributeMap.update({
        __orientation.name() : __orientation
    })
_module_typeBindings.OrientableSurfaceType = OrientableSurfaceType
_Namespace_gml.addCategoryObject('typeBinding', 'OrientableSurfaceType', OrientableSurfaceType)


# Complex type {http://www.opengis.net/gml/3.2}SolidType with content type ELEMENT_ONLY
class SolidType (AbstractSolidType):
    """Complex type {http://www.opengis.net/gml/3.2}SolidType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'SolidType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 804, 1)
    _ElementMap = AbstractSolidType._ElementMap.copy()
    _AttributeMap = AbstractSolidType._AttributeMap.copy()
    # Base type is AbstractSolidType
    
    # Element metaDataProperty ({http://www.opengis.net/gml/3.2}metaDataProperty) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element {http://www.opengis.net/gml/3.2}exterior uses Python identifier exterior
    __exterior = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'exterior'), 'exterior', '__httpwww_opengis_netgml3_2_SolidType_httpwww_opengis_netgml3_2exterior', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 808, 5), )

    
    exterior = property(__exterior.value, __exterior.set, None, None)

    
    # Element {http://www.opengis.net/gml/3.2}interior uses Python identifier interior
    __interior = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'interior'), 'interior', '__httpwww_opengis_netgml3_2_SolidType_httpwww_opengis_netgml3_2interior', True, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 809, 5), )

    
    interior = property(__interior.value, __interior.set, None, None)

    
    # Element description ({http://www.opengis.net/gml/3.2}description) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element descriptionReference ({http://www.opengis.net/gml/3.2}descriptionReference) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element name ({http://www.opengis.net/gml/3.2}name) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element identifier ({http://www.opengis.net/gml/3.2}identifier) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Attribute srsName inherited from {http://www.opengis.net/gml/3.2}AbstractGeometryType
    
    # Attribute srsDimension inherited from {http://www.opengis.net/gml/3.2}AbstractGeometryType
    
    # Attribute axisLabels inherited from {http://www.opengis.net/gml/3.2}AbstractGeometryType
    
    # Attribute uomLabels inherited from {http://www.opengis.net/gml/3.2}AbstractGeometryType
    
    # Attribute id inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    _ElementMap.update({
        __exterior.name() : __exterior,
        __interior.name() : __interior
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.SolidType = SolidType
_Namespace_gml.addCategoryObject('typeBinding', 'SolidType', SolidType)


# Complex type {http://www.opengis.net/gml/3.2}ShellType with content type ELEMENT_ONLY
class ShellType (AbstractSurfaceType):
    """Complex type {http://www.opengis.net/gml/3.2}ShellType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'ShellType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 819, 1)
    _ElementMap = AbstractSurfaceType._ElementMap.copy()
    _AttributeMap = AbstractSurfaceType._AttributeMap.copy()
    # Base type is AbstractSurfaceType
    
    # Element metaDataProperty ({http://www.opengis.net/gml/3.2}metaDataProperty) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element {http://www.opengis.net/gml/3.2}surfaceMember uses Python identifier surfaceMember
    __surfaceMember = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'surfaceMember'), 'surfaceMember', '__httpwww_opengis_netgml3_2_ShellType_httpwww_opengis_netgml3_2surfaceMember', True, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 837, 1), )

    
    surfaceMember = property(__surfaceMember.value, __surfaceMember.set, None, 'This property element either references a surface via the XLink-attributes or contains the surface element. A surface element is any element, which is substitutable for gml:AbstractSurface.')

    
    # Element description ({http://www.opengis.net/gml/3.2}description) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element descriptionReference ({http://www.opengis.net/gml/3.2}descriptionReference) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element name ({http://www.opengis.net/gml/3.2}name) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element identifier ({http://www.opengis.net/gml/3.2}identifier) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Attribute srsName inherited from {http://www.opengis.net/gml/3.2}AbstractGeometryType
    
    # Attribute srsDimension inherited from {http://www.opengis.net/gml/3.2}AbstractGeometryType
    
    # Attribute axisLabels inherited from {http://www.opengis.net/gml/3.2}AbstractGeometryType
    
    # Attribute uomLabels inherited from {http://www.opengis.net/gml/3.2}AbstractGeometryType
    
    # Attribute id inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Attribute aggregationType uses Python identifier aggregationType
    __aggregationType = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'aggregationType'), 'aggregationType', '__httpwww_opengis_netgml3_2_ShellType_aggregationType', _module_typeBindings.AggregationType)
    __aggregationType._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 158, 2)
    __aggregationType._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 158, 2)
    
    aggregationType = property(__aggregationType.value, __aggregationType.set, None, None)

    _ElementMap.update({
        __surfaceMember.name() : __surfaceMember
    })
    _AttributeMap.update({
        __aggregationType.name() : __aggregationType
    })
_module_typeBindings.ShellType = ShellType
_Namespace_gml.addCategoryObject('typeBinding', 'ShellType', ShellType)


# Complex type {http://www.opengis.net/gml/3.2}DirectedObservationAtDistanceType with content type ELEMENT_ONLY
class DirectedObservationAtDistanceType (DirectedObservationType):
    """Complex type {http://www.opengis.net/gml/3.2}DirectedObservationAtDistanceType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'DirectedObservationAtDistanceType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/observation.xsd', 86, 1)
    _ElementMap = DirectedObservationType._ElementMap.copy()
    _AttributeMap = DirectedObservationType._AttributeMap.copy()
    # Base type is DirectedObservationType
    
    # Element metaDataProperty ({http://www.opengis.net/gml/3.2}metaDataProperty) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element location ({http://www.opengis.net/gml/3.2}location) inherited from {http://www.opengis.net/gml/3.2}AbstractFeatureType
    
    # Element direction ({http://www.opengis.net/gml/3.2}direction) inherited from {http://www.opengis.net/gml/3.2}DirectedObservationType
    
    # Element boundedBy ({http://www.opengis.net/gml/3.2}boundedBy) inherited from {http://www.opengis.net/gml/3.2}AbstractFeatureType
    
    # Element description ({http://www.opengis.net/gml/3.2}description) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element descriptionReference ({http://www.opengis.net/gml/3.2}descriptionReference) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element name ({http://www.opengis.net/gml/3.2}name) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element identifier ({http://www.opengis.net/gml/3.2}identifier) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element using ({http://www.opengis.net/gml/3.2}using) inherited from {http://www.opengis.net/gml/3.2}ObservationType
    
    # Element target ({http://www.opengis.net/gml/3.2}target) inherited from {http://www.opengis.net/gml/3.2}ObservationType
    
    # Element resultOf ({http://www.opengis.net/gml/3.2}resultOf) inherited from {http://www.opengis.net/gml/3.2}ObservationType
    
    # Element {http://www.opengis.net/gml/3.2}distance uses Python identifier distance
    __distance = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'distance'), 'distance', '__httpwww_opengis_netgml3_2_DirectedObservationAtDistanceType_httpwww_opengis_netgml3_2distance', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/observation.xsd', 90, 5), )

    
    distance = property(__distance.value, __distance.set, None, None)

    
    # Element validTime ({http://www.opengis.net/gml/3.2}validTime) inherited from {http://www.opengis.net/gml/3.2}ObservationType
    
    # Attribute id inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    _ElementMap.update({
        __distance.name() : __distance
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.DirectedObservationAtDistanceType = DirectedObservationAtDistanceType
_Namespace_gml.addCategoryObject('typeBinding', 'DirectedObservationAtDistanceType', DirectedObservationAtDistanceType)


# Complex type {http://www.opengis.net/gml/3.2}AbstractCRSType with content type ELEMENT_ONLY
class AbstractCRSType (IdentifiedObjectType):
    """Complex type {http://www.opengis.net/gml/3.2}AbstractCRSType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = True
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractCRSType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/referenceSystems.xsd', 35, 1)
    _ElementMap = IdentifiedObjectType._ElementMap.copy()
    _AttributeMap = IdentifiedObjectType._AttributeMap.copy()
    # Base type is IdentifiedObjectType
    
    # Element metaDataProperty ({http://www.opengis.net/gml/3.2}metaDataProperty) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element remarks ({http://www.opengis.net/gml/3.2}remarks) inherited from {http://www.opengis.net/gml/3.2}DefinitionType
    
    # Element description ({http://www.opengis.net/gml/3.2}description) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element descriptionReference ({http://www.opengis.net/gml/3.2}descriptionReference) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element name ({http://www.opengis.net/gml/3.2}name) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element identifier ({http://www.opengis.net/gml/3.2}identifier) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element {http://www.opengis.net/gml/3.2}domainOfValidity uses Python identifier domainOfValidity
    __domainOfValidity = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'domainOfValidity'), 'domainOfValidity', '__httpwww_opengis_netgml3_2_AbstractCRSType_httpwww_opengis_netgml3_2domainOfValidity', True, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/referenceSystems.xsd', 45, 1), )

    
    domainOfValidity = property(__domainOfValidity.value, __domainOfValidity.set, None, 'The gml:domainOfValidity property implements an association role to an EX_Extent object as encoded in ISO/TS 19139, either referencing or containing the definition of that extent.')

    
    # Element {http://www.opengis.net/gml/3.2}scope uses Python identifier scope
    __scope = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'scope'), 'scope', '__httpwww_opengis_netgml3_2_AbstractCRSType_httpwww_opengis_netgml3_2scope', True, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/referenceSystems.xsd', 56, 1), )

    
    scope = property(__scope.value, __scope.set, None, 'The gml:scope property provides a description of the usage, or limitations of usage, for which this CRS-related object is valid. If unknown, enter "not known".')

    
    # Attribute id_ inherited from {http://www.opengis.net/gml/3.2}DefinitionBaseType
    _ElementMap.update({
        __domainOfValidity.name() : __domainOfValidity,
        __scope.name() : __scope
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.AbstractCRSType = AbstractCRSType
_Namespace_gml.addCategoryObject('typeBinding', 'AbstractCRSType', AbstractCRSType)


# Complex type {http://www.opengis.net/gml/3.2}TimeInstantType with content type ELEMENT_ONLY
class TimeInstantType (AbstractTimeGeometricPrimitiveType):
    """Complex type {http://www.opengis.net/gml/3.2}TimeInstantType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'TimeInstantType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporal.xsd', 114, 1)
    _ElementMap = AbstractTimeGeometricPrimitiveType._ElementMap.copy()
    _AttributeMap = AbstractTimeGeometricPrimitiveType._AttributeMap.copy()
    # Base type is AbstractTimeGeometricPrimitiveType
    
    # Element metaDataProperty ({http://www.opengis.net/gml/3.2}metaDataProperty) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element description ({http://www.opengis.net/gml/3.2}description) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element descriptionReference ({http://www.opengis.net/gml/3.2}descriptionReference) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element name ({http://www.opengis.net/gml/3.2}name) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element identifier ({http://www.opengis.net/gml/3.2}identifier) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element relatedTime ({http://www.opengis.net/gml/3.2}relatedTime) inherited from {http://www.opengis.net/gml/3.2}AbstractTimePrimitiveType
    
    # Element {http://www.opengis.net/gml/3.2}timePosition uses Python identifier timePosition
    __timePosition = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'timePosition'), 'timePosition', '__httpwww_opengis_netgml3_2_TimeInstantType_httpwww_opengis_netgml3_2timePosition', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporal.xsd', 215, 1), )

    
    timePosition = property(__timePosition.value, __timePosition.set, None, 'This element is used directly as a property of gml:TimeInstant (see 15.2.2.3), and may also be used in application schemas.')

    
    # Attribute id inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Attribute frame inherited from {http://www.opengis.net/gml/3.2}AbstractTimeGeometricPrimitiveType
    _ElementMap.update({
        __timePosition.name() : __timePosition
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.TimeInstantType = TimeInstantType
_Namespace_gml.addCategoryObject('typeBinding', 'TimeInstantType', TimeInstantType)


# Complex type {http://www.opengis.net/gml/3.2}TimePeriodType with content type ELEMENT_ONLY
class TimePeriodType (AbstractTimeGeometricPrimitiveType):
    """Complex type {http://www.opengis.net/gml/3.2}TimePeriodType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'TimePeriodType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporal.xsd', 141, 1)
    _ElementMap = AbstractTimeGeometricPrimitiveType._ElementMap.copy()
    _AttributeMap = AbstractTimeGeometricPrimitiveType._AttributeMap.copy()
    # Base type is AbstractTimeGeometricPrimitiveType
    
    # Element metaDataProperty ({http://www.opengis.net/gml/3.2}metaDataProperty) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element description ({http://www.opengis.net/gml/3.2}description) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element descriptionReference ({http://www.opengis.net/gml/3.2}descriptionReference) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element name ({http://www.opengis.net/gml/3.2}name) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element identifier ({http://www.opengis.net/gml/3.2}identifier) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element relatedTime ({http://www.opengis.net/gml/3.2}relatedTime) inherited from {http://www.opengis.net/gml/3.2}AbstractTimePrimitiveType
    
    # Element {http://www.opengis.net/gml/3.2}beginPosition uses Python identifier beginPosition
    __beginPosition = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'beginPosition'), 'beginPosition', '__httpwww_opengis_netgml3_2_TimePeriodType_httpwww_opengis_netgml3_2beginPosition', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporal.xsd', 146, 6), )

    
    beginPosition = property(__beginPosition.value, __beginPosition.set, None, None)

    
    # Element {http://www.opengis.net/gml/3.2}begin uses Python identifier begin
    __begin = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'begin'), 'begin', '__httpwww_opengis_netgml3_2_TimePeriodType_httpwww_opengis_netgml3_2begin', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporal.xsd', 147, 6), )

    
    begin = property(__begin.value, __begin.set, None, None)

    
    # Element {http://www.opengis.net/gml/3.2}endPosition uses Python identifier endPosition
    __endPosition = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'endPosition'), 'endPosition', '__httpwww_opengis_netgml3_2_TimePeriodType_httpwww_opengis_netgml3_2endPosition', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporal.xsd', 150, 6), )

    
    endPosition = property(__endPosition.value, __endPosition.set, None, None)

    
    # Element {http://www.opengis.net/gml/3.2}end uses Python identifier end
    __end = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'end'), 'end', '__httpwww_opengis_netgml3_2_TimePeriodType_httpwww_opengis_netgml3_2end', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporal.xsd', 151, 6), )

    
    end = property(__end.value, __end.set, None, None)

    
    # Element {http://www.opengis.net/gml/3.2}duration uses Python identifier duration
    __duration = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'duration'), 'duration', '__httpwww_opengis_netgml3_2_TimePeriodType_httpwww_opengis_netgml3_2duration', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporal.xsd', 229, 1), )

    
    duration = property(__duration.value, __duration.set, None, 'gml:duration conforms to the ISO 8601 syntax for temporal length as implemented by the XML Schema duration type.')

    
    # Element {http://www.opengis.net/gml/3.2}timeInterval uses Python identifier timeInterval
    __timeInterval = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'timeInterval'), 'timeInterval', '__httpwww_opengis_netgml3_2_TimePeriodType_httpwww_opengis_netgml3_2timeInterval', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporal.xsd', 234, 1), )

    
    timeInterval = property(__timeInterval.value, __timeInterval.set, None, ' gml:timeInterval conforms to ISO 11404 which is based on floating point values for temporal length.\nISO 11404 syntax specifies the use of a positiveInteger together with appropriate values for radix and factor. The resolution of the time interval is to one radix ^(-factor) of the specified time unit.\nThe value of the unit is either selected from the units for time intervals from ISO 31-1:1992, or is another suitable unit.  The encoding is defined for GML in gml:TimeUnitType. The second component of this union type provides a method for indicating time units other than the six standard units given in the enumeration.')

    
    # Attribute id inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Attribute frame inherited from {http://www.opengis.net/gml/3.2}AbstractTimeGeometricPrimitiveType
    _ElementMap.update({
        __beginPosition.name() : __beginPosition,
        __begin.name() : __begin,
        __endPosition.name() : __endPosition,
        __end.name() : __end,
        __duration.name() : __duration,
        __timeInterval.name() : __timeInterval
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.TimePeriodType = TimePeriodType
_Namespace_gml.addCategoryObject('typeBinding', 'TimePeriodType', TimePeriodType)


# Complex type {http://www.opengis.net/gml/3.2}TimeCoordinateSystemType with content type ELEMENT_ONLY
class TimeCoordinateSystemType (TimeReferenceSystemType):
    """Complex type {http://www.opengis.net/gml/3.2}TimeCoordinateSystemType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'TimeCoordinateSystemType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporalReferenceSystems.xsd', 40, 1)
    _ElementMap = TimeReferenceSystemType._ElementMap.copy()
    _AttributeMap = TimeReferenceSystemType._AttributeMap.copy()
    # Base type is TimeReferenceSystemType
    
    # Element metaDataProperty ({http://www.opengis.net/gml/3.2}metaDataProperty) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element remarks ({http://www.opengis.net/gml/3.2}remarks) inherited from {http://www.opengis.net/gml/3.2}DefinitionType
    
    # Element description ({http://www.opengis.net/gml/3.2}description) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element descriptionReference ({http://www.opengis.net/gml/3.2}descriptionReference) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element name ({http://www.opengis.net/gml/3.2}name) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element identifier ({http://www.opengis.net/gml/3.2}identifier) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element domainOfValidity ({http://www.opengis.net/gml/3.2}domainOfValidity) inherited from {http://www.opengis.net/gml/3.2}TimeReferenceSystemType
    
    # Element {http://www.opengis.net/gml/3.2}originPosition uses Python identifier originPosition
    __originPosition = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'originPosition'), 'originPosition', '__httpwww_opengis_netgml3_2_TimeCoordinateSystemType_httpwww_opengis_netgml3_2originPosition', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporalReferenceSystems.xsd', 45, 6), )

    
    originPosition = property(__originPosition.value, __originPosition.set, None, None)

    
    # Element {http://www.opengis.net/gml/3.2}origin uses Python identifier origin
    __origin = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'origin'), 'origin', '__httpwww_opengis_netgml3_2_TimeCoordinateSystemType_httpwww_opengis_netgml3_2origin', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporalReferenceSystems.xsd', 46, 6), )

    
    origin = property(__origin.value, __origin.set, None, None)

    
    # Element {http://www.opengis.net/gml/3.2}interval uses Python identifier interval
    __interval = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'interval'), 'interval', '__httpwww_opengis_netgml3_2_TimeCoordinateSystemType_httpwww_opengis_netgml3_2interval', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporalReferenceSystems.xsd', 48, 5), )

    
    interval = property(__interval.value, __interval.set, None, None)

    
    # Attribute id_ inherited from {http://www.opengis.net/gml/3.2}DefinitionBaseType
    _ElementMap.update({
        __originPosition.name() : __originPosition,
        __origin.name() : __origin,
        __interval.name() : __interval
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.TimeCoordinateSystemType = TimeCoordinateSystemType
_Namespace_gml.addCategoryObject('typeBinding', 'TimeCoordinateSystemType', TimeCoordinateSystemType)


# Complex type {http://www.opengis.net/gml/3.2}TimeCalendarType with content type ELEMENT_ONLY
class TimeCalendarType (TimeReferenceSystemType):
    """Complex type {http://www.opengis.net/gml/3.2}TimeCalendarType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'TimeCalendarType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporalReferenceSystems.xsd', 60, 1)
    _ElementMap = TimeReferenceSystemType._ElementMap.copy()
    _AttributeMap = TimeReferenceSystemType._AttributeMap.copy()
    # Base type is TimeReferenceSystemType
    
    # Element metaDataProperty ({http://www.opengis.net/gml/3.2}metaDataProperty) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element remarks ({http://www.opengis.net/gml/3.2}remarks) inherited from {http://www.opengis.net/gml/3.2}DefinitionType
    
    # Element description ({http://www.opengis.net/gml/3.2}description) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element descriptionReference ({http://www.opengis.net/gml/3.2}descriptionReference) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element name ({http://www.opengis.net/gml/3.2}name) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element identifier ({http://www.opengis.net/gml/3.2}identifier) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element domainOfValidity ({http://www.opengis.net/gml/3.2}domainOfValidity) inherited from {http://www.opengis.net/gml/3.2}TimeReferenceSystemType
    
    # Element {http://www.opengis.net/gml/3.2}referenceFrame uses Python identifier referenceFrame
    __referenceFrame = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'referenceFrame'), 'referenceFrame', '__httpwww_opengis_netgml3_2_TimeCalendarType_httpwww_opengis_netgml3_2referenceFrame', True, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporalReferenceSystems.xsd', 64, 5), )

    
    referenceFrame = property(__referenceFrame.value, __referenceFrame.set, None, None)

    
    # Attribute id_ inherited from {http://www.opengis.net/gml/3.2}DefinitionBaseType
    _ElementMap.update({
        __referenceFrame.name() : __referenceFrame
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.TimeCalendarType = TimeCalendarType
_Namespace_gml.addCategoryObject('typeBinding', 'TimeCalendarType', TimeCalendarType)


# Complex type {http://www.opengis.net/gml/3.2}TimeClockType with content type ELEMENT_ONLY
class TimeClockType (TimeReferenceSystemType):
    """Complex type {http://www.opengis.net/gml/3.2}TimeClockType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'TimeClockType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporalReferenceSystems.xsd', 120, 1)
    _ElementMap = TimeReferenceSystemType._ElementMap.copy()
    _AttributeMap = TimeReferenceSystemType._AttributeMap.copy()
    # Base type is TimeReferenceSystemType
    
    # Element metaDataProperty ({http://www.opengis.net/gml/3.2}metaDataProperty) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element remarks ({http://www.opengis.net/gml/3.2}remarks) inherited from {http://www.opengis.net/gml/3.2}DefinitionType
    
    # Element description ({http://www.opengis.net/gml/3.2}description) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element descriptionReference ({http://www.opengis.net/gml/3.2}descriptionReference) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element name ({http://www.opengis.net/gml/3.2}name) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element identifier ({http://www.opengis.net/gml/3.2}identifier) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element domainOfValidity ({http://www.opengis.net/gml/3.2}domainOfValidity) inherited from {http://www.opengis.net/gml/3.2}TimeReferenceSystemType
    
    # Element {http://www.opengis.net/gml/3.2}referenceEvent uses Python identifier referenceEvent
    __referenceEvent = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'referenceEvent'), 'referenceEvent', '__httpwww_opengis_netgml3_2_TimeClockType_httpwww_opengis_netgml3_2referenceEvent', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporalReferenceSystems.xsd', 124, 5), )

    
    referenceEvent = property(__referenceEvent.value, __referenceEvent.set, None, None)

    
    # Element {http://www.opengis.net/gml/3.2}referenceTime uses Python identifier referenceTime
    __referenceTime = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'referenceTime'), 'referenceTime', '__httpwww_opengis_netgml3_2_TimeClockType_httpwww_opengis_netgml3_2referenceTime', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporalReferenceSystems.xsd', 125, 5), )

    
    referenceTime = property(__referenceTime.value, __referenceTime.set, None, None)

    
    # Element {http://www.opengis.net/gml/3.2}utcReference uses Python identifier utcReference
    __utcReference = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'utcReference'), 'utcReference', '__httpwww_opengis_netgml3_2_TimeClockType_httpwww_opengis_netgml3_2utcReference', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporalReferenceSystems.xsd', 126, 5), )

    
    utcReference = property(__utcReference.value, __utcReference.set, None, None)

    
    # Element {http://www.opengis.net/gml/3.2}dateBasis uses Python identifier dateBasis
    __dateBasis = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'dateBasis'), 'dateBasis', '__httpwww_opengis_netgml3_2_TimeClockType_httpwww_opengis_netgml3_2dateBasis', True, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporalReferenceSystems.xsd', 127, 5), )

    
    dateBasis = property(__dateBasis.value, __dateBasis.set, None, None)

    
    # Attribute id_ inherited from {http://www.opengis.net/gml/3.2}DefinitionBaseType
    _ElementMap.update({
        __referenceEvent.name() : __referenceEvent,
        __referenceTime.name() : __referenceTime,
        __utcReference.name() : __utcReference,
        __dateBasis.name() : __dateBasis
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.TimeClockType = TimeClockType
_Namespace_gml.addCategoryObject('typeBinding', 'TimeClockType', TimeClockType)


# Complex type {http://www.opengis.net/gml/3.2}TimeOrdinalReferenceSystemType with content type ELEMENT_ONLY
class TimeOrdinalReferenceSystemType (TimeReferenceSystemType):
    """Complex type {http://www.opengis.net/gml/3.2}TimeOrdinalReferenceSystemType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'TimeOrdinalReferenceSystemType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporalReferenceSystems.xsd', 150, 1)
    _ElementMap = TimeReferenceSystemType._ElementMap.copy()
    _AttributeMap = TimeReferenceSystemType._AttributeMap.copy()
    # Base type is TimeReferenceSystemType
    
    # Element metaDataProperty ({http://www.opengis.net/gml/3.2}metaDataProperty) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element remarks ({http://www.opengis.net/gml/3.2}remarks) inherited from {http://www.opengis.net/gml/3.2}DefinitionType
    
    # Element description ({http://www.opengis.net/gml/3.2}description) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element descriptionReference ({http://www.opengis.net/gml/3.2}descriptionReference) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element name ({http://www.opengis.net/gml/3.2}name) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element identifier ({http://www.opengis.net/gml/3.2}identifier) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element domainOfValidity ({http://www.opengis.net/gml/3.2}domainOfValidity) inherited from {http://www.opengis.net/gml/3.2}TimeReferenceSystemType
    
    # Element {http://www.opengis.net/gml/3.2}component uses Python identifier component
    __component = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'component'), 'component', '__httpwww_opengis_netgml3_2_TimeOrdinalReferenceSystemType_httpwww_opengis_netgml3_2component', True, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporalReferenceSystems.xsd', 154, 5), )

    
    component = property(__component.value, __component.set, None, None)

    
    # Attribute id_ inherited from {http://www.opengis.net/gml/3.2}DefinitionBaseType
    _ElementMap.update({
        __component.name() : __component
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.TimeOrdinalReferenceSystemType = TimeOrdinalReferenceSystemType
_Namespace_gml.addCategoryObject('typeBinding', 'TimeOrdinalReferenceSystemType', TimeOrdinalReferenceSystemType)


# Complex type {http://www.opengis.net/gml/3.2}TimeNodeType with content type ELEMENT_ONLY
class TimeNodeType (AbstractTimeTopologyPrimitiveType):
    """Complex type {http://www.opengis.net/gml/3.2}TimeNodeType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'TimeNodeType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporalTopology.xsd', 72, 1)
    _ElementMap = AbstractTimeTopologyPrimitiveType._ElementMap.copy()
    _AttributeMap = AbstractTimeTopologyPrimitiveType._AttributeMap.copy()
    # Base type is AbstractTimeTopologyPrimitiveType
    
    # Element metaDataProperty ({http://www.opengis.net/gml/3.2}metaDataProperty) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element description ({http://www.opengis.net/gml/3.2}description) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element descriptionReference ({http://www.opengis.net/gml/3.2}descriptionReference) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element name ({http://www.opengis.net/gml/3.2}name) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element identifier ({http://www.opengis.net/gml/3.2}identifier) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element relatedTime ({http://www.opengis.net/gml/3.2}relatedTime) inherited from {http://www.opengis.net/gml/3.2}AbstractTimePrimitiveType
    
    # Element complex ({http://www.opengis.net/gml/3.2}complex) inherited from {http://www.opengis.net/gml/3.2}AbstractTimeTopologyPrimitiveType
    
    # Element {http://www.opengis.net/gml/3.2}previousEdge uses Python identifier previousEdge
    __previousEdge = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'previousEdge'), 'previousEdge', '__httpwww_opengis_netgml3_2_TimeNodeType_httpwww_opengis_netgml3_2previousEdge', True, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporalTopology.xsd', 76, 5), )

    
    previousEdge = property(__previousEdge.value, __previousEdge.set, None, None)

    
    # Element {http://www.opengis.net/gml/3.2}nextEdge uses Python identifier nextEdge
    __nextEdge = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'nextEdge'), 'nextEdge', '__httpwww_opengis_netgml3_2_TimeNodeType_httpwww_opengis_netgml3_2nextEdge', True, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporalTopology.xsd', 77, 5), )

    
    nextEdge = property(__nextEdge.value, __nextEdge.set, None, None)

    
    # Element {http://www.opengis.net/gml/3.2}position uses Python identifier position
    __position = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'position'), 'position', '__httpwww_opengis_netgml3_2_TimeNodeType_httpwww_opengis_netgml3_2position', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporalTopology.xsd', 78, 5), )

    
    position = property(__position.value, __position.set, None, None)

    
    # Attribute id inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    _ElementMap.update({
        __previousEdge.name() : __previousEdge,
        __nextEdge.name() : __nextEdge,
        __position.name() : __position
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.TimeNodeType = TimeNodeType
_Namespace_gml.addCategoryObject('typeBinding', 'TimeNodeType', TimeNodeType)


# Complex type {http://www.opengis.net/gml/3.2}TimeEdgeType with content type ELEMENT_ONLY
class TimeEdgeType (AbstractTimeTopologyPrimitiveType):
    """Complex type {http://www.opengis.net/gml/3.2}TimeEdgeType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'TimeEdgeType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporalTopology.xsd', 98, 1)
    _ElementMap = AbstractTimeTopologyPrimitiveType._ElementMap.copy()
    _AttributeMap = AbstractTimeTopologyPrimitiveType._AttributeMap.copy()
    # Base type is AbstractTimeTopologyPrimitiveType
    
    # Element metaDataProperty ({http://www.opengis.net/gml/3.2}metaDataProperty) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element description ({http://www.opengis.net/gml/3.2}description) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element descriptionReference ({http://www.opengis.net/gml/3.2}descriptionReference) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element name ({http://www.opengis.net/gml/3.2}name) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element identifier ({http://www.opengis.net/gml/3.2}identifier) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element relatedTime ({http://www.opengis.net/gml/3.2}relatedTime) inherited from {http://www.opengis.net/gml/3.2}AbstractTimePrimitiveType
    
    # Element complex ({http://www.opengis.net/gml/3.2}complex) inherited from {http://www.opengis.net/gml/3.2}AbstractTimeTopologyPrimitiveType
    
    # Element {http://www.opengis.net/gml/3.2}start uses Python identifier start
    __start = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'start'), 'start', '__httpwww_opengis_netgml3_2_TimeEdgeType_httpwww_opengis_netgml3_2start', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporalTopology.xsd', 102, 5), )

    
    start = property(__start.value, __start.set, None, None)

    
    # Element {http://www.opengis.net/gml/3.2}end uses Python identifier end
    __end = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'end'), 'end', '__httpwww_opengis_netgml3_2_TimeEdgeType_httpwww_opengis_netgml3_2end', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporalTopology.xsd', 103, 5), )

    
    end = property(__end.value, __end.set, None, None)

    
    # Element {http://www.opengis.net/gml/3.2}extent uses Python identifier extent
    __extent = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'extent'), 'extent', '__httpwww_opengis_netgml3_2_TimeEdgeType_httpwww_opengis_netgml3_2extent', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporalTopology.xsd', 104, 5), )

    
    extent = property(__extent.value, __extent.set, None, None)

    
    # Attribute id inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    _ElementMap.update({
        __start.name() : __start,
        __end.name() : __end,
        __extent.name() : __extent
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.TimeEdgeType = TimeEdgeType
_Namespace_gml.addCategoryObject('typeBinding', 'TimeEdgeType', TimeEdgeType)


# Complex type {http://www.opengis.net/gml/3.2}BaseUnitType with content type ELEMENT_ONLY
class BaseUnitType (UnitDefinitionType):
    """Complex type {http://www.opengis.net/gml/3.2}BaseUnitType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'BaseUnitType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/units.xsd', 71, 1)
    _ElementMap = UnitDefinitionType._ElementMap.copy()
    _AttributeMap = UnitDefinitionType._AttributeMap.copy()
    # Base type is UnitDefinitionType
    
    # Element metaDataProperty ({http://www.opengis.net/gml/3.2}metaDataProperty) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element remarks ({http://www.opengis.net/gml/3.2}remarks) inherited from {http://www.opengis.net/gml/3.2}DefinitionType
    
    # Element description ({http://www.opengis.net/gml/3.2}description) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element descriptionReference ({http://www.opengis.net/gml/3.2}descriptionReference) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element name ({http://www.opengis.net/gml/3.2}name) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element identifier ({http://www.opengis.net/gml/3.2}identifier) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element quantityType ({http://www.opengis.net/gml/3.2}quantityType) inherited from {http://www.opengis.net/gml/3.2}UnitDefinitionType
    
    # Element quantityTypeReference ({http://www.opengis.net/gml/3.2}quantityTypeReference) inherited from {http://www.opengis.net/gml/3.2}UnitDefinitionType
    
    # Element catalogSymbol ({http://www.opengis.net/gml/3.2}catalogSymbol) inherited from {http://www.opengis.net/gml/3.2}UnitDefinitionType
    
    # Element {http://www.opengis.net/gml/3.2}unitsSystem uses Python identifier unitsSystem
    __unitsSystem = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'unitsSystem'), 'unitsSystem', '__httpwww_opengis_netgml3_2_BaseUnitType_httpwww_opengis_netgml3_2unitsSystem', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/units.xsd', 75, 5), )

    
    unitsSystem = property(__unitsSystem.value, __unitsSystem.set, None, None)

    
    # Attribute id_ inherited from {http://www.opengis.net/gml/3.2}DefinitionBaseType
    _ElementMap.update({
        __unitsSystem.name() : __unitsSystem
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.BaseUnitType = BaseUnitType
_Namespace_gml.addCategoryObject('typeBinding', 'BaseUnitType', BaseUnitType)


# Complex type {http://www.opengis.net/gml/3.2}DerivedUnitType with content type ELEMENT_ONLY
class DerivedUnitType (UnitDefinitionType):
    """Complex type {http://www.opengis.net/gml/3.2}DerivedUnitType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'DerivedUnitType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/units.xsd', 86, 1)
    _ElementMap = UnitDefinitionType._ElementMap.copy()
    _AttributeMap = UnitDefinitionType._AttributeMap.copy()
    # Base type is UnitDefinitionType
    
    # Element metaDataProperty ({http://www.opengis.net/gml/3.2}metaDataProperty) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element remarks ({http://www.opengis.net/gml/3.2}remarks) inherited from {http://www.opengis.net/gml/3.2}DefinitionType
    
    # Element description ({http://www.opengis.net/gml/3.2}description) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element descriptionReference ({http://www.opengis.net/gml/3.2}descriptionReference) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element name ({http://www.opengis.net/gml/3.2}name) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element identifier ({http://www.opengis.net/gml/3.2}identifier) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element quantityType ({http://www.opengis.net/gml/3.2}quantityType) inherited from {http://www.opengis.net/gml/3.2}UnitDefinitionType
    
    # Element quantityTypeReference ({http://www.opengis.net/gml/3.2}quantityTypeReference) inherited from {http://www.opengis.net/gml/3.2}UnitDefinitionType
    
    # Element catalogSymbol ({http://www.opengis.net/gml/3.2}catalogSymbol) inherited from {http://www.opengis.net/gml/3.2}UnitDefinitionType
    
    # Element {http://www.opengis.net/gml/3.2}derivationUnitTerm uses Python identifier derivationUnitTerm
    __derivationUnitTerm = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'derivationUnitTerm'), 'derivationUnitTerm', '__httpwww_opengis_netgml3_2_DerivedUnitType_httpwww_opengis_netgml3_2derivationUnitTerm', True, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/units.xsd', 95, 1), )

    
    derivationUnitTerm = property(__derivationUnitTerm.value, __derivationUnitTerm.set, None, 'A set of gml:derivationUnitTerm elements describes a derived unit of measure.  Each element carries an integer exponent.  The terms are combined by raising each referenced unit to the power of its exponent and forming the product.\nThis unit term references another unit of measure (uom) and provides an integer exponent applied to that unit in defining the compound unit. The exponent may be positive or negative, but not zero.')

    
    # Attribute id_ inherited from {http://www.opengis.net/gml/3.2}DefinitionBaseType
    _ElementMap.update({
        __derivationUnitTerm.name() : __derivationUnitTerm
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.DerivedUnitType = DerivedUnitType
_Namespace_gml.addCategoryObject('typeBinding', 'DerivedUnitType', DerivedUnitType)


# Complex type {http://www.opengis.net/gml/3.2}ConventionalUnitType with content type ELEMENT_ONLY
class ConventionalUnitType (UnitDefinitionType):
    """Complex type {http://www.opengis.net/gml/3.2}ConventionalUnitType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'ConventionalUnitType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/units.xsd', 114, 1)
    _ElementMap = UnitDefinitionType._ElementMap.copy()
    _AttributeMap = UnitDefinitionType._AttributeMap.copy()
    # Base type is UnitDefinitionType
    
    # Element metaDataProperty ({http://www.opengis.net/gml/3.2}metaDataProperty) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element remarks ({http://www.opengis.net/gml/3.2}remarks) inherited from {http://www.opengis.net/gml/3.2}DefinitionType
    
    # Element description ({http://www.opengis.net/gml/3.2}description) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element descriptionReference ({http://www.opengis.net/gml/3.2}descriptionReference) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element name ({http://www.opengis.net/gml/3.2}name) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element identifier ({http://www.opengis.net/gml/3.2}identifier) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element quantityType ({http://www.opengis.net/gml/3.2}quantityType) inherited from {http://www.opengis.net/gml/3.2}UnitDefinitionType
    
    # Element quantityTypeReference ({http://www.opengis.net/gml/3.2}quantityTypeReference) inherited from {http://www.opengis.net/gml/3.2}UnitDefinitionType
    
    # Element catalogSymbol ({http://www.opengis.net/gml/3.2}catalogSymbol) inherited from {http://www.opengis.net/gml/3.2}UnitDefinitionType
    
    # Element {http://www.opengis.net/gml/3.2}derivationUnitTerm uses Python identifier derivationUnitTerm
    __derivationUnitTerm = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'derivationUnitTerm'), 'derivationUnitTerm', '__httpwww_opengis_netgml3_2_ConventionalUnitType_httpwww_opengis_netgml3_2derivationUnitTerm', True, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/units.xsd', 95, 1), )

    
    derivationUnitTerm = property(__derivationUnitTerm.value, __derivationUnitTerm.set, None, 'A set of gml:derivationUnitTerm elements describes a derived unit of measure.  Each element carries an integer exponent.  The terms are combined by raising each referenced unit to the power of its exponent and forming the product.\nThis unit term references another unit of measure (uom) and provides an integer exponent applied to that unit in defining the compound unit. The exponent may be positive or negative, but not zero.')

    
    # Element {http://www.opengis.net/gml/3.2}conversionToPreferredUnit uses Python identifier conversionToPreferredUnit
    __conversionToPreferredUnit = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'conversionToPreferredUnit'), 'conversionToPreferredUnit', '__httpwww_opengis_netgml3_2_ConventionalUnitType_httpwww_opengis_netgml3_2conversionToPreferredUnit', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/units.xsd', 127, 1), )

    
    conversionToPreferredUnit = property(__conversionToPreferredUnit.value, __conversionToPreferredUnit.set, None, 'The elements gml:conversionToPreferredUnit and gml:roughConversionToPreferredUnit represent parameters used to convert conventional units to preferred units for this physical quantity type.  A preferred unit is either a Base Unit or a Derived Unit that is selected for all values of one physical quantity type.')

    
    # Element {http://www.opengis.net/gml/3.2}roughConversionToPreferredUnit uses Python identifier roughConversionToPreferredUnit
    __roughConversionToPreferredUnit = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'roughConversionToPreferredUnit'), 'roughConversionToPreferredUnit', '__httpwww_opengis_netgml3_2_ConventionalUnitType_httpwww_opengis_netgml3_2roughConversionToPreferredUnit', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/units.xsd', 132, 1), )

    
    roughConversionToPreferredUnit = property(__roughConversionToPreferredUnit.value, __roughConversionToPreferredUnit.set, None, 'The elements gml:conversionToPreferredUnit and gml:roughConversionToPreferredUnit represent parameters used to convert conventional units to preferred units for this physical quantity type.  A preferred unit is either a Base Unit or a Derived Unit that is selected for all values of one physical quantity type.')

    
    # Attribute id_ inherited from {http://www.opengis.net/gml/3.2}DefinitionBaseType
    _ElementMap.update({
        __derivationUnitTerm.name() : __derivationUnitTerm,
        __conversionToPreferredUnit.name() : __conversionToPreferredUnit,
        __roughConversionToPreferredUnit.name() : __roughConversionToPreferredUnit
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.ConventionalUnitType = ConventionalUnitType
_Namespace_gml.addCategoryObject('typeBinding', 'ConventionalUnitType', ConventionalUnitType)


# Complex type {http://www.opengis.net/gml/3.2}CategoryExtentType with content type SIMPLE
class CategoryExtentType (CodeOrNilReasonListType):
    """Complex type {http://www.opengis.net/gml/3.2}CategoryExtentType with content type SIMPLE"""
    _TypeDefinition = STD_ANON_8
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_SIMPLE
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'CategoryExtentType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/valueObjects.xsd', 160, 1)
    _ElementMap = CodeOrNilReasonListType._ElementMap.copy()
    _AttributeMap = CodeOrNilReasonListType._AttributeMap.copy()
    # Base type is CodeOrNilReasonListType
    
    # Attribute codeSpace inherited from {http://www.opengis.net/gml/3.2}CodeOrNilReasonListType
    _ElementMap.update({
        
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.CategoryExtentType = CategoryExtentType
_Namespace_gml.addCategoryObject('typeBinding', 'CategoryExtentType', CategoryExtentType)


# Complex type {http://www.opengis.net/gml/3.2}QuantityExtentType with content type SIMPLE
class QuantityExtentType (MeasureOrNilReasonListType):
    """Complex type {http://www.opengis.net/gml/3.2}QuantityExtentType with content type SIMPLE"""
    _TypeDefinition = STD_ANON_9
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_SIMPLE
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'QuantityExtentType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/valueObjects.xsd', 174, 1)
    _ElementMap = MeasureOrNilReasonListType._ElementMap.copy()
    _AttributeMap = MeasureOrNilReasonListType._AttributeMap.copy()
    # Base type is MeasureOrNilReasonListType
    
    # Attribute uom inherited from {http://www.opengis.net/gml/3.2}MeasureOrNilReasonListType
    _ElementMap.update({
        
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.QuantityExtentType = QuantityExtentType
_Namespace_gml.addCategoryObject('typeBinding', 'QuantityExtentType', QuantityExtentType)


# Complex type {http://www.opengis.net/gml/3.2}AbstractGeneralConversionType with content type ELEMENT_ONLY
class AbstractGeneralConversionType (AbstractCoordinateOperationType):
    """Complex type {http://www.opengis.net/gml/3.2}AbstractGeneralConversionType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = True
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractGeneralConversionType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 98, 1)
    _ElementMap = AbstractCoordinateOperationType._ElementMap.copy()
    _AttributeMap = AbstractCoordinateOperationType._AttributeMap.copy()
    # Base type is AbstractCoordinateOperationType
    
    # Element coordinateOperationAccuracy ({http://www.opengis.net/gml/3.2}coordinateOperationAccuracy) inherited from {http://www.opengis.net/gml/3.2}AbstractCoordinateOperationType
    
    # Element metaDataProperty ({http://www.opengis.net/gml/3.2}metaDataProperty) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element remarks ({http://www.opengis.net/gml/3.2}remarks) inherited from {http://www.opengis.net/gml/3.2}DefinitionType
    
    # Element description ({http://www.opengis.net/gml/3.2}description) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element descriptionReference ({http://www.opengis.net/gml/3.2}descriptionReference) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element name ({http://www.opengis.net/gml/3.2}name) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element identifier ({http://www.opengis.net/gml/3.2}identifier) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element domainOfValidity ({http://www.opengis.net/gml/3.2}domainOfValidity) inherited from {http://www.opengis.net/gml/3.2}AbstractCoordinateOperationType
    
    # Element scope ({http://www.opengis.net/gml/3.2}scope) inherited from {http://www.opengis.net/gml/3.2}AbstractCoordinateOperationType
    
    # Attribute id is restricted from parent
    
    # Attribute {http://www.opengis.net/gml/3.2}id uses Python identifier id
    __id = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gml, 'id'), 'id', '__httpwww_opengis_netgml3_2_AbstractGMLType_httpwww_opengis_netgml3_2id', pyxb.binding.datatypes.ID, required=True)
    __id._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 137, 1)
    __id._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 112, 4)
    
    id = property(__id.value, __id.set, None, 'The attribute gml:id supports provision of a handle for the XML element representing a GML Object. Its use is mandatory for all GML objects. It is of XML type ID, so is constrained to be unique in the XML document within which it occurs.')

    _ElementMap.update({
        
    })
    _AttributeMap.update({
        __id.name() : __id
    })
_module_typeBindings.AbstractGeneralConversionType = AbstractGeneralConversionType
_Namespace_gml.addCategoryObject('typeBinding', 'AbstractGeneralConversionType', AbstractGeneralConversionType)


# Complex type {http://www.opengis.net/gml/3.2}AbstractGeneralTransformationType with content type ELEMENT_ONLY
class AbstractGeneralTransformationType (AbstractCoordinateOperationType):
    """Complex type {http://www.opengis.net/gml/3.2}AbstractGeneralTransformationType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = True
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractGeneralTransformationType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 131, 1)
    _ElementMap = AbstractCoordinateOperationType._ElementMap.copy()
    _AttributeMap = AbstractCoordinateOperationType._AttributeMap.copy()
    # Base type is AbstractCoordinateOperationType
    
    # Element operationVersion ({http://www.opengis.net/gml/3.2}operationVersion) inherited from {http://www.opengis.net/gml/3.2}AbstractCoordinateOperationType
    
    # Element coordinateOperationAccuracy ({http://www.opengis.net/gml/3.2}coordinateOperationAccuracy) inherited from {http://www.opengis.net/gml/3.2}AbstractCoordinateOperationType
    
    # Element sourceCRS ({http://www.opengis.net/gml/3.2}sourceCRS) inherited from {http://www.opengis.net/gml/3.2}AbstractCoordinateOperationType
    
    # Element targetCRS ({http://www.opengis.net/gml/3.2}targetCRS) inherited from {http://www.opengis.net/gml/3.2}AbstractCoordinateOperationType
    
    # Element metaDataProperty ({http://www.opengis.net/gml/3.2}metaDataProperty) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element remarks ({http://www.opengis.net/gml/3.2}remarks) inherited from {http://www.opengis.net/gml/3.2}DefinitionType
    
    # Element description ({http://www.opengis.net/gml/3.2}description) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element descriptionReference ({http://www.opengis.net/gml/3.2}descriptionReference) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element name ({http://www.opengis.net/gml/3.2}name) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element identifier ({http://www.opengis.net/gml/3.2}identifier) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element domainOfValidity ({http://www.opengis.net/gml/3.2}domainOfValidity) inherited from {http://www.opengis.net/gml/3.2}AbstractCoordinateOperationType
    
    # Element scope ({http://www.opengis.net/gml/3.2}scope) inherited from {http://www.opengis.net/gml/3.2}AbstractCoordinateOperationType
    
    # Attribute id is restricted from parent
    
    # Attribute {http://www.opengis.net/gml/3.2}id uses Python identifier id
    __id = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gml, 'id'), 'id', '__httpwww_opengis_netgml3_2_AbstractGMLType_httpwww_opengis_netgml3_2id', pyxb.binding.datatypes.ID, required=True)
    __id._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 137, 1)
    __id._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 148, 4)
    
    id = property(__id.value, __id.set, None, 'The attribute gml:id supports provision of a handle for the XML element representing a GML Object. Its use is mandatory for all GML objects. It is of XML type ID, so is constrained to be unique in the XML document within which it occurs.')

    _ElementMap.update({
        
    })
    _AttributeMap.update({
        __id.name() : __id
    })
_module_typeBindings.AbstractGeneralTransformationType = AbstractGeneralTransformationType
_Namespace_gml.addCategoryObject('typeBinding', 'AbstractGeneralTransformationType', AbstractGeneralTransformationType)


# Complex type {http://www.opengis.net/gml/3.2}ConcatenatedOperationType with content type ELEMENT_ONLY
class ConcatenatedOperationType (AbstractCoordinateOperationType):
    """gml:ConcatenatedOperation is an ordered sequence of two or more coordinate operations. This sequence of operations is constrained by the requirement that the source coordinate reference system of step (n+1) must be the same as the target coordinate reference system of step (n). The source coordinate reference system of the first step and the target coordinate reference system of the last step are the source and target coordinate reference system associated with the concatenated operation. Instead of a forward operation, an inverse operation may be used for one or more of the operation steps mentioned above, if the inverse operation is uniquely defined by the forward operation.
The gml:coordOperation property elements are an ordered sequence of associations to the two or more operations used by this concatenated operation. The AggregationAttributeGroup should be used to specify that the coordOperation associations are ordered."""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'ConcatenatedOperationType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 162, 1)
    _ElementMap = AbstractCoordinateOperationType._ElementMap.copy()
    _AttributeMap = AbstractCoordinateOperationType._AttributeMap.copy()
    # Base type is AbstractCoordinateOperationType
    
    # Element operationVersion ({http://www.opengis.net/gml/3.2}operationVersion) inherited from {http://www.opengis.net/gml/3.2}AbstractCoordinateOperationType
    
    # Element coordinateOperationAccuracy ({http://www.opengis.net/gml/3.2}coordinateOperationAccuracy) inherited from {http://www.opengis.net/gml/3.2}AbstractCoordinateOperationType
    
    # Element sourceCRS ({http://www.opengis.net/gml/3.2}sourceCRS) inherited from {http://www.opengis.net/gml/3.2}AbstractCoordinateOperationType
    
    # Element targetCRS ({http://www.opengis.net/gml/3.2}targetCRS) inherited from {http://www.opengis.net/gml/3.2}AbstractCoordinateOperationType
    
    # Element {http://www.opengis.net/gml/3.2}coordOperation uses Python identifier coordOperation
    __coordOperation = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'coordOperation'), 'coordOperation', '__httpwww_opengis_netgml3_2_ConcatenatedOperationType_httpwww_opengis_netgml3_2coordOperation', True, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 176, 1), )

    
    coordOperation = property(__coordOperation.value, __coordOperation.set, None, 'gml:coordOperation is an association role to a coordinate operation.')

    
    # Element metaDataProperty ({http://www.opengis.net/gml/3.2}metaDataProperty) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element remarks ({http://www.opengis.net/gml/3.2}remarks) inherited from {http://www.opengis.net/gml/3.2}DefinitionType
    
    # Element description ({http://www.opengis.net/gml/3.2}description) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element descriptionReference ({http://www.opengis.net/gml/3.2}descriptionReference) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element name ({http://www.opengis.net/gml/3.2}name) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element identifier ({http://www.opengis.net/gml/3.2}identifier) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element domainOfValidity ({http://www.opengis.net/gml/3.2}domainOfValidity) inherited from {http://www.opengis.net/gml/3.2}AbstractCoordinateOperationType
    
    # Element scope ({http://www.opengis.net/gml/3.2}scope) inherited from {http://www.opengis.net/gml/3.2}AbstractCoordinateOperationType
    
    # Attribute id_ inherited from {http://www.opengis.net/gml/3.2}DefinitionBaseType
    
    # Attribute aggregationType uses Python identifier aggregationType
    __aggregationType = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'aggregationType'), 'aggregationType', '__httpwww_opengis_netgml3_2_ConcatenatedOperationType_aggregationType', _module_typeBindings.AggregationType)
    __aggregationType._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 158, 2)
    __aggregationType._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 158, 2)
    
    aggregationType = property(__aggregationType.value, __aggregationType.set, None, None)

    _ElementMap.update({
        __coordOperation.name() : __coordOperation
    })
    _AttributeMap.update({
        __aggregationType.name() : __aggregationType
    })
_module_typeBindings.ConcatenatedOperationType = ConcatenatedOperationType
_Namespace_gml.addCategoryObject('typeBinding', 'ConcatenatedOperationType', ConcatenatedOperationType)


# Complex type {http://www.opengis.net/gml/3.2}PassThroughOperationType with content type ELEMENT_ONLY
class PassThroughOperationType (AbstractCoordinateOperationType):
    """Complex type {http://www.opengis.net/gml/3.2}PassThroughOperationType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'PassThroughOperationType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 196, 1)
    _ElementMap = AbstractCoordinateOperationType._ElementMap.copy()
    _AttributeMap = AbstractCoordinateOperationType._AttributeMap.copy()
    # Base type is AbstractCoordinateOperationType
    
    # Element operationVersion ({http://www.opengis.net/gml/3.2}operationVersion) inherited from {http://www.opengis.net/gml/3.2}AbstractCoordinateOperationType
    
    # Element coordinateOperationAccuracy ({http://www.opengis.net/gml/3.2}coordinateOperationAccuracy) inherited from {http://www.opengis.net/gml/3.2}AbstractCoordinateOperationType
    
    # Element sourceCRS ({http://www.opengis.net/gml/3.2}sourceCRS) inherited from {http://www.opengis.net/gml/3.2}AbstractCoordinateOperationType
    
    # Element targetCRS ({http://www.opengis.net/gml/3.2}targetCRS) inherited from {http://www.opengis.net/gml/3.2}AbstractCoordinateOperationType
    
    # Element {http://www.opengis.net/gml/3.2}coordOperation uses Python identifier coordOperation
    __coordOperation = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'coordOperation'), 'coordOperation', '__httpwww_opengis_netgml3_2_PassThroughOperationType_httpwww_opengis_netgml3_2coordOperation', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 176, 1), )

    
    coordOperation = property(__coordOperation.value, __coordOperation.set, None, 'gml:coordOperation is an association role to a coordinate operation.')

    
    # Element {http://www.opengis.net/gml/3.2}modifiedCoordinate uses Python identifier modifiedCoordinate
    __modifiedCoordinate = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'modifiedCoordinate'), 'modifiedCoordinate', '__httpwww_opengis_netgml3_2_PassThroughOperationType_httpwww_opengis_netgml3_2modifiedCoordinate', True, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 207, 1), )

    
    modifiedCoordinate = property(__modifiedCoordinate.value, __modifiedCoordinate.set, None, 'gml:modifiedCoordinate is a positive integer defining a position in a coordinate tuple.')

    
    # Element metaDataProperty ({http://www.opengis.net/gml/3.2}metaDataProperty) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element remarks ({http://www.opengis.net/gml/3.2}remarks) inherited from {http://www.opengis.net/gml/3.2}DefinitionType
    
    # Element description ({http://www.opengis.net/gml/3.2}description) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element descriptionReference ({http://www.opengis.net/gml/3.2}descriptionReference) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element name ({http://www.opengis.net/gml/3.2}name) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element identifier ({http://www.opengis.net/gml/3.2}identifier) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element domainOfValidity ({http://www.opengis.net/gml/3.2}domainOfValidity) inherited from {http://www.opengis.net/gml/3.2}AbstractCoordinateOperationType
    
    # Element scope ({http://www.opengis.net/gml/3.2}scope) inherited from {http://www.opengis.net/gml/3.2}AbstractCoordinateOperationType
    
    # Attribute id_ inherited from {http://www.opengis.net/gml/3.2}DefinitionBaseType
    
    # Attribute aggregationType uses Python identifier aggregationType
    __aggregationType = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'aggregationType'), 'aggregationType', '__httpwww_opengis_netgml3_2_PassThroughOperationType_aggregationType', _module_typeBindings.AggregationType)
    __aggregationType._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 158, 2)
    __aggregationType._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 158, 2)
    
    aggregationType = property(__aggregationType.value, __aggregationType.set, None, None)

    _ElementMap.update({
        __coordOperation.name() : __coordOperation,
        __modifiedCoordinate.name() : __modifiedCoordinate
    })
    _AttributeMap.update({
        __aggregationType.name() : __aggregationType
    })
_module_typeBindings.PassThroughOperationType = PassThroughOperationType
_Namespace_gml.addCategoryObject('typeBinding', 'PassThroughOperationType', PassThroughOperationType)


# Complex type {http://www.opengis.net/gml/3.2}OperationParameterType with content type ELEMENT_ONLY
class OperationParameterType (AbstractGeneralOperationParameterType):
    """Complex type {http://www.opengis.net/gml/3.2}OperationParameterType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'OperationParameterType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 479, 1)
    _ElementMap = AbstractGeneralOperationParameterType._ElementMap.copy()
    _AttributeMap = AbstractGeneralOperationParameterType._AttributeMap.copy()
    # Base type is AbstractGeneralOperationParameterType
    
    # Element minimumOccurs ({http://www.opengis.net/gml/3.2}minimumOccurs) inherited from {http://www.opengis.net/gml/3.2}AbstractGeneralOperationParameterType
    
    # Element metaDataProperty ({http://www.opengis.net/gml/3.2}metaDataProperty) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element remarks ({http://www.opengis.net/gml/3.2}remarks) inherited from {http://www.opengis.net/gml/3.2}DefinitionType
    
    # Element description ({http://www.opengis.net/gml/3.2}description) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element descriptionReference ({http://www.opengis.net/gml/3.2}descriptionReference) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element name ({http://www.opengis.net/gml/3.2}name) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element identifier ({http://www.opengis.net/gml/3.2}identifier) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Attribute id_ inherited from {http://www.opengis.net/gml/3.2}DefinitionBaseType
    _ElementMap.update({
        
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.OperationParameterType = OperationParameterType
_Namespace_gml.addCategoryObject('typeBinding', 'OperationParameterType', OperationParameterType)


# Complex type {http://www.opengis.net/gml/3.2}OperationParameterGroupType with content type ELEMENT_ONLY
class OperationParameterGroupType (AbstractGeneralOperationParameterType):
    """Complex type {http://www.opengis.net/gml/3.2}OperationParameterGroupType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'OperationParameterGroupType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 501, 1)
    _ElementMap = AbstractGeneralOperationParameterType._ElementMap.copy()
    _AttributeMap = AbstractGeneralOperationParameterType._AttributeMap.copy()
    # Base type is AbstractGeneralOperationParameterType
    
    # Element {http://www.opengis.net/gml/3.2}parameter uses Python identifier parameter
    __parameter = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'parameter'), 'parameter', '__httpwww_opengis_netgml3_2_OperationParameterGroupType_httpwww_opengis_netgml3_2parameter', True, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 432, 1), )

    
    parameter = property(__parameter.value, __parameter.set, None, 'gml:parameter is an association to an operation parameter or parameter group.')

    
    # Element minimumOccurs ({http://www.opengis.net/gml/3.2}minimumOccurs) inherited from {http://www.opengis.net/gml/3.2}AbstractGeneralOperationParameterType
    
    # Element {http://www.opengis.net/gml/3.2}maximumOccurs uses Python identifier maximumOccurs
    __maximumOccurs = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'maximumOccurs'), 'maximumOccurs', '__httpwww_opengis_netgml3_2_OperationParameterGroupType_httpwww_opengis_netgml3_2maximumOccurs', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 511, 1), )

    
    maximumOccurs = property(__maximumOccurs.value, __maximumOccurs.set, None, 'gml:maximumOccurs is the maximum number of times that values for this parameter group may be included. If this attribute is omitted, the maximum number shall be one.')

    
    # Element metaDataProperty ({http://www.opengis.net/gml/3.2}metaDataProperty) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element remarks ({http://www.opengis.net/gml/3.2}remarks) inherited from {http://www.opengis.net/gml/3.2}DefinitionType
    
    # Element description ({http://www.opengis.net/gml/3.2}description) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element descriptionReference ({http://www.opengis.net/gml/3.2}descriptionReference) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element name ({http://www.opengis.net/gml/3.2}name) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element identifier ({http://www.opengis.net/gml/3.2}identifier) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Attribute id_ inherited from {http://www.opengis.net/gml/3.2}DefinitionBaseType
    _ElementMap.update({
        __parameter.name() : __parameter,
        __maximumOccurs.name() : __maximumOccurs
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.OperationParameterGroupType = OperationParameterGroupType
_Namespace_gml.addCategoryObject('typeBinding', 'OperationParameterGroupType', OperationParameterGroupType)


# Complex type {http://www.opengis.net/gml/3.2}AbstractGeneralDerivedCRSType with content type ELEMENT_ONLY
class AbstractGeneralDerivedCRSType (AbstractCRSType):
    """Complex type {http://www.opengis.net/gml/3.2}AbstractGeneralDerivedCRSType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = True
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractGeneralDerivedCRSType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateReferenceSystems.xsd', 37, 1)
    _ElementMap = AbstractCRSType._ElementMap.copy()
    _AttributeMap = AbstractCRSType._AttributeMap.copy()
    # Base type is AbstractCRSType
    
    # Element {http://www.opengis.net/gml/3.2}conversion uses Python identifier conversion
    __conversion = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'conversion'), 'conversion', '__httpwww_opengis_netgml3_2_AbstractGeneralDerivedCRSType_httpwww_opengis_netgml3_2conversion', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateReferenceSystems.xsd', 46, 1), )

    
    conversion = property(__conversion.value, __conversion.set, None, 'gml:conversion is an association role to the coordinate conversion used to define the derived CRS.')

    
    # Element metaDataProperty ({http://www.opengis.net/gml/3.2}metaDataProperty) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element remarks ({http://www.opengis.net/gml/3.2}remarks) inherited from {http://www.opengis.net/gml/3.2}DefinitionType
    
    # Element description ({http://www.opengis.net/gml/3.2}description) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element descriptionReference ({http://www.opengis.net/gml/3.2}descriptionReference) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element name ({http://www.opengis.net/gml/3.2}name) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element identifier ({http://www.opengis.net/gml/3.2}identifier) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element domainOfValidity ({http://www.opengis.net/gml/3.2}domainOfValidity) inherited from {http://www.opengis.net/gml/3.2}AbstractCRSType
    
    # Element scope ({http://www.opengis.net/gml/3.2}scope) inherited from {http://www.opengis.net/gml/3.2}AbstractCRSType
    
    # Attribute id_ inherited from {http://www.opengis.net/gml/3.2}DefinitionBaseType
    _ElementMap.update({
        __conversion.name() : __conversion
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.AbstractGeneralDerivedCRSType = AbstractGeneralDerivedCRSType
_Namespace_gml.addCategoryObject('typeBinding', 'AbstractGeneralDerivedCRSType', AbstractGeneralDerivedCRSType)


# Complex type {http://www.opengis.net/gml/3.2}CompoundCRSType with content type ELEMENT_ONLY
class CompoundCRSType (AbstractCRSType):
    """Complex type {http://www.opengis.net/gml/3.2}CompoundCRSType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'CompoundCRSType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateReferenceSystems.xsd', 56, 1)
    _ElementMap = AbstractCRSType._ElementMap.copy()
    _AttributeMap = AbstractCRSType._AttributeMap.copy()
    # Base type is AbstractCRSType
    
    # Element {http://www.opengis.net/gml/3.2}componentReferenceSystem uses Python identifier componentReferenceSystem
    __componentReferenceSystem = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'componentReferenceSystem'), 'componentReferenceSystem', '__httpwww_opengis_netgml3_2_CompoundCRSType_httpwww_opengis_netgml3_2componentReferenceSystem', True, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateReferenceSystems.xsd', 66, 1), )

    
    componentReferenceSystem = property(__componentReferenceSystem.value, __componentReferenceSystem.set, None, 'The gml:componentReferenceSystem elements are an ordered sequence of associations to all the component coordinate reference systems included in this compound coordinate reference system. The gml:AggregationAttributeGroup should be used to specify that the gml:componentReferenceSystem properties are ordered.')

    
    # Element metaDataProperty ({http://www.opengis.net/gml/3.2}metaDataProperty) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element remarks ({http://www.opengis.net/gml/3.2}remarks) inherited from {http://www.opengis.net/gml/3.2}DefinitionType
    
    # Element description ({http://www.opengis.net/gml/3.2}description) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element descriptionReference ({http://www.opengis.net/gml/3.2}descriptionReference) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element name ({http://www.opengis.net/gml/3.2}name) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element identifier ({http://www.opengis.net/gml/3.2}identifier) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element domainOfValidity ({http://www.opengis.net/gml/3.2}domainOfValidity) inherited from {http://www.opengis.net/gml/3.2}AbstractCRSType
    
    # Element scope ({http://www.opengis.net/gml/3.2}scope) inherited from {http://www.opengis.net/gml/3.2}AbstractCRSType
    
    # Attribute id_ inherited from {http://www.opengis.net/gml/3.2}DefinitionBaseType
    
    # Attribute aggregationType uses Python identifier aggregationType
    __aggregationType = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'aggregationType'), 'aggregationType', '__httpwww_opengis_netgml3_2_CompoundCRSType_aggregationType', _module_typeBindings.AggregationType)
    __aggregationType._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 158, 2)
    __aggregationType._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 158, 2)
    
    aggregationType = property(__aggregationType.value, __aggregationType.set, None, None)

    _ElementMap.update({
        __componentReferenceSystem.name() : __componentReferenceSystem
    })
    _AttributeMap.update({
        __aggregationType.name() : __aggregationType
    })
_module_typeBindings.CompoundCRSType = CompoundCRSType
_Namespace_gml.addCategoryObject('typeBinding', 'CompoundCRSType', CompoundCRSType)


# Complex type {http://www.opengis.net/gml/3.2}GeodeticCRSType with content type ELEMENT_ONLY
class GeodeticCRSType (AbstractCRSType):
    """gml:GeodeticCRS is a coordinate reference system based on a geodetic datum."""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'GeodeticCRSType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateReferenceSystems.xsd', 81, 1)
    _ElementMap = AbstractCRSType._ElementMap.copy()
    _AttributeMap = AbstractCRSType._AttributeMap.copy()
    # Base type is AbstractCRSType
    
    # Element {http://www.opengis.net/gml/3.2}ellipsoidalCS uses Python identifier ellipsoidalCS
    __ellipsoidalCS = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'ellipsoidalCS'), 'ellipsoidalCS', '__httpwww_opengis_netgml3_2_GeodeticCRSType_httpwww_opengis_netgml3_2ellipsoidalCS', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateReferenceSystems.xsd', 98, 1), )

    
    ellipsoidalCS = property(__ellipsoidalCS.value, __ellipsoidalCS.set, None, 'gml:ellipsoidalCS is an association role to the ellipsoidal coordinate system used by this CRS.')

    
    # Element {http://www.opengis.net/gml/3.2}cartesianCS uses Python identifier cartesianCS
    __cartesianCS = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'cartesianCS'), 'cartesianCS', '__httpwww_opengis_netgml3_2_GeodeticCRSType_httpwww_opengis_netgml3_2cartesianCS', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateReferenceSystems.xsd', 103, 1), )

    
    cartesianCS = property(__cartesianCS.value, __cartesianCS.set, None, 'gml:cartesianCS is an association role to the Cartesian coordinate system used by this CRS.')

    
    # Element {http://www.opengis.net/gml/3.2}sphericalCS uses Python identifier sphericalCS
    __sphericalCS = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'sphericalCS'), 'sphericalCS', '__httpwww_opengis_netgml3_2_GeodeticCRSType_httpwww_opengis_netgml3_2sphericalCS', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateReferenceSystems.xsd', 108, 1), )

    
    sphericalCS = property(__sphericalCS.value, __sphericalCS.set, None, 'gml:sphericalCS is an association role to the spherical coordinate system used by this CRS.')

    
    # Element {http://www.opengis.net/gml/3.2}geodeticDatum uses Python identifier geodeticDatum
    __geodeticDatum = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'geodeticDatum'), 'geodeticDatum', '__httpwww_opengis_netgml3_2_GeodeticCRSType_httpwww_opengis_netgml3_2geodeticDatum', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateReferenceSystems.xsd', 113, 1), )

    
    geodeticDatum = property(__geodeticDatum.value, __geodeticDatum.set, None, 'gml:geodeticDatum is an association role to the geodetic datum used by this CRS.\n')

    
    # Element metaDataProperty ({http://www.opengis.net/gml/3.2}metaDataProperty) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element remarks ({http://www.opengis.net/gml/3.2}remarks) inherited from {http://www.opengis.net/gml/3.2}DefinitionType
    
    # Element description ({http://www.opengis.net/gml/3.2}description) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element descriptionReference ({http://www.opengis.net/gml/3.2}descriptionReference) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element name ({http://www.opengis.net/gml/3.2}name) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element identifier ({http://www.opengis.net/gml/3.2}identifier) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element domainOfValidity ({http://www.opengis.net/gml/3.2}domainOfValidity) inherited from {http://www.opengis.net/gml/3.2}AbstractCRSType
    
    # Element scope ({http://www.opengis.net/gml/3.2}scope) inherited from {http://www.opengis.net/gml/3.2}AbstractCRSType
    
    # Attribute id_ inherited from {http://www.opengis.net/gml/3.2}DefinitionBaseType
    _ElementMap.update({
        __ellipsoidalCS.name() : __ellipsoidalCS,
        __cartesianCS.name() : __cartesianCS,
        __sphericalCS.name() : __sphericalCS,
        __geodeticDatum.name() : __geodeticDatum
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.GeodeticCRSType = GeodeticCRSType
_Namespace_gml.addCategoryObject('typeBinding', 'GeodeticCRSType', GeodeticCRSType)


# Complex type {http://www.opengis.net/gml/3.2}VerticalCRSType with content type ELEMENT_ONLY
class VerticalCRSType (AbstractCRSType):
    """Complex type {http://www.opengis.net/gml/3.2}VerticalCRSType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'VerticalCRSType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateReferenceSystems.xsd', 133, 1)
    _ElementMap = AbstractCRSType._ElementMap.copy()
    _AttributeMap = AbstractCRSType._AttributeMap.copy()
    # Base type is AbstractCRSType
    
    # Element {http://www.opengis.net/gml/3.2}verticalCS uses Python identifier verticalCS
    __verticalCS = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'verticalCS'), 'verticalCS', '__httpwww_opengis_netgml3_2_VerticalCRSType_httpwww_opengis_netgml3_2verticalCS', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateReferenceSystems.xsd', 143, 1), )

    
    verticalCS = property(__verticalCS.value, __verticalCS.set, None, 'gml:verticalCS is an association role to the vertical coordinate system used by this CRS.')

    
    # Element {http://www.opengis.net/gml/3.2}verticalDatum uses Python identifier verticalDatum
    __verticalDatum = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'verticalDatum'), 'verticalDatum', '__httpwww_opengis_netgml3_2_VerticalCRSType_httpwww_opengis_netgml3_2verticalDatum', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateReferenceSystems.xsd', 148, 1), )

    
    verticalDatum = property(__verticalDatum.value, __verticalDatum.set, None, 'gml:verticalDatum is an association role to the vertical datum used by this CRS.')

    
    # Element metaDataProperty ({http://www.opengis.net/gml/3.2}metaDataProperty) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element remarks ({http://www.opengis.net/gml/3.2}remarks) inherited from {http://www.opengis.net/gml/3.2}DefinitionType
    
    # Element description ({http://www.opengis.net/gml/3.2}description) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element descriptionReference ({http://www.opengis.net/gml/3.2}descriptionReference) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element name ({http://www.opengis.net/gml/3.2}name) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element identifier ({http://www.opengis.net/gml/3.2}identifier) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element domainOfValidity ({http://www.opengis.net/gml/3.2}domainOfValidity) inherited from {http://www.opengis.net/gml/3.2}AbstractCRSType
    
    # Element scope ({http://www.opengis.net/gml/3.2}scope) inherited from {http://www.opengis.net/gml/3.2}AbstractCRSType
    
    # Attribute id_ inherited from {http://www.opengis.net/gml/3.2}DefinitionBaseType
    _ElementMap.update({
        __verticalCS.name() : __verticalCS,
        __verticalDatum.name() : __verticalDatum
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.VerticalCRSType = VerticalCRSType
_Namespace_gml.addCategoryObject('typeBinding', 'VerticalCRSType', VerticalCRSType)


# Complex type {http://www.opengis.net/gml/3.2}EngineeringCRSType with content type ELEMENT_ONLY
class EngineeringCRSType (AbstractCRSType):
    """Complex type {http://www.opengis.net/gml/3.2}EngineeringCRSType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'EngineeringCRSType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateReferenceSystems.xsd', 241, 1)
    _ElementMap = AbstractCRSType._ElementMap.copy()
    _AttributeMap = AbstractCRSType._AttributeMap.copy()
    # Base type is AbstractCRSType
    
    # Element {http://www.opengis.net/gml/3.2}cartesianCS uses Python identifier cartesianCS
    __cartesianCS = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'cartesianCS'), 'cartesianCS', '__httpwww_opengis_netgml3_2_EngineeringCRSType_httpwww_opengis_netgml3_2cartesianCS', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateReferenceSystems.xsd', 103, 1), )

    
    cartesianCS = property(__cartesianCS.value, __cartesianCS.set, None, 'gml:cartesianCS is an association role to the Cartesian coordinate system used by this CRS.')

    
    # Element {http://www.opengis.net/gml/3.2}sphericalCS uses Python identifier sphericalCS
    __sphericalCS = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'sphericalCS'), 'sphericalCS', '__httpwww_opengis_netgml3_2_EngineeringCRSType_httpwww_opengis_netgml3_2sphericalCS', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateReferenceSystems.xsd', 108, 1), )

    
    sphericalCS = property(__sphericalCS.value, __sphericalCS.set, None, 'gml:sphericalCS is an association role to the spherical coordinate system used by this CRS.')

    
    # Element {http://www.opengis.net/gml/3.2}coordinateSystem uses Python identifier coordinateSystem
    __coordinateSystem = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'coordinateSystem'), 'coordinateSystem', '__httpwww_opengis_netgml3_2_EngineeringCRSType_httpwww_opengis_netgml3_2coordinateSystem', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateReferenceSystems.xsd', 220, 1), )

    
    coordinateSystem = property(__coordinateSystem.value, __coordinateSystem.set, None, 'An association role to the coordinate system used by this CRS.')

    
    # Element {http://www.opengis.net/gml/3.2}cylindricalCS uses Python identifier cylindricalCS
    __cylindricalCS = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'cylindricalCS'), 'cylindricalCS', '__httpwww_opengis_netgml3_2_EngineeringCRSType_httpwww_opengis_netgml3_2cylindricalCS', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateReferenceSystems.xsd', 264, 1), )

    
    cylindricalCS = property(__cylindricalCS.value, __cylindricalCS.set, None, 'gml:cylindricalCS is an association role to the cylindrical coordinate system used by this CRS.')

    
    # Element {http://www.opengis.net/gml/3.2}linearCS uses Python identifier linearCS
    __linearCS = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'linearCS'), 'linearCS', '__httpwww_opengis_netgml3_2_EngineeringCRSType_httpwww_opengis_netgml3_2linearCS', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateReferenceSystems.xsd', 269, 1), )

    
    linearCS = property(__linearCS.value, __linearCS.set, None, 'gml:linearCS is an association role to the linear coordinate system used by this CRS.')

    
    # Element {http://www.opengis.net/gml/3.2}polarCS uses Python identifier polarCS
    __polarCS = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'polarCS'), 'polarCS', '__httpwww_opengis_netgml3_2_EngineeringCRSType_httpwww_opengis_netgml3_2polarCS', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateReferenceSystems.xsd', 274, 1), )

    
    polarCS = property(__polarCS.value, __polarCS.set, None, 'gml:polarCS is an association role to the polar coordinate system used by this CRS.')

    
    # Element {http://www.opengis.net/gml/3.2}userDefinedCS uses Python identifier userDefinedCS
    __userDefinedCS = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'userDefinedCS'), 'userDefinedCS', '__httpwww_opengis_netgml3_2_EngineeringCRSType_httpwww_opengis_netgml3_2userDefinedCS', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateReferenceSystems.xsd', 279, 1), )

    
    userDefinedCS = property(__userDefinedCS.value, __userDefinedCS.set, None, 'gml:userDefinedCS is an association role to the user defined coordinate system used by this CRS.')

    
    # Element {http://www.opengis.net/gml/3.2}engineeringDatum uses Python identifier engineeringDatum
    __engineeringDatum = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'engineeringDatum'), 'engineeringDatum', '__httpwww_opengis_netgml3_2_EngineeringCRSType_httpwww_opengis_netgml3_2engineeringDatum', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateReferenceSystems.xsd', 284, 1), )

    
    engineeringDatum = property(__engineeringDatum.value, __engineeringDatum.set, None, 'gml:engineeringDatum is an association role to the engineering datum used by this CRS.')

    
    # Element {http://www.opengis.net/gml/3.2}affineCS uses Python identifier affineCS
    __affineCS = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'affineCS'), 'affineCS', '__httpwww_opengis_netgml3_2_EngineeringCRSType_httpwww_opengis_netgml3_2affineCS', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateReferenceSystems.xsd', 317, 1), )

    
    affineCS = property(__affineCS.value, __affineCS.set, None, 'gml:affineCS is an association role to the affine coordinate system used by this CRS.')

    
    # Element metaDataProperty ({http://www.opengis.net/gml/3.2}metaDataProperty) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element remarks ({http://www.opengis.net/gml/3.2}remarks) inherited from {http://www.opengis.net/gml/3.2}DefinitionType
    
    # Element description ({http://www.opengis.net/gml/3.2}description) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element descriptionReference ({http://www.opengis.net/gml/3.2}descriptionReference) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element name ({http://www.opengis.net/gml/3.2}name) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element identifier ({http://www.opengis.net/gml/3.2}identifier) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element domainOfValidity ({http://www.opengis.net/gml/3.2}domainOfValidity) inherited from {http://www.opengis.net/gml/3.2}AbstractCRSType
    
    # Element scope ({http://www.opengis.net/gml/3.2}scope) inherited from {http://www.opengis.net/gml/3.2}AbstractCRSType
    
    # Attribute id_ inherited from {http://www.opengis.net/gml/3.2}DefinitionBaseType
    _ElementMap.update({
        __cartesianCS.name() : __cartesianCS,
        __sphericalCS.name() : __sphericalCS,
        __coordinateSystem.name() : __coordinateSystem,
        __cylindricalCS.name() : __cylindricalCS,
        __linearCS.name() : __linearCS,
        __polarCS.name() : __polarCS,
        __userDefinedCS.name() : __userDefinedCS,
        __engineeringDatum.name() : __engineeringDatum,
        __affineCS.name() : __affineCS
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.EngineeringCRSType = EngineeringCRSType
_Namespace_gml.addCategoryObject('typeBinding', 'EngineeringCRSType', EngineeringCRSType)


# Complex type {http://www.opengis.net/gml/3.2}ImageCRSType with content type ELEMENT_ONLY
class ImageCRSType (AbstractCRSType):
    """Complex type {http://www.opengis.net/gml/3.2}ImageCRSType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'ImageCRSType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateReferenceSystems.xsd', 303, 1)
    _ElementMap = AbstractCRSType._ElementMap.copy()
    _AttributeMap = AbstractCRSType._AttributeMap.copy()
    # Base type is AbstractCRSType
    
    # Element {http://www.opengis.net/gml/3.2}cartesianCS uses Python identifier cartesianCS
    __cartesianCS = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'cartesianCS'), 'cartesianCS', '__httpwww_opengis_netgml3_2_ImageCRSType_httpwww_opengis_netgml3_2cartesianCS', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateReferenceSystems.xsd', 103, 1), )

    
    cartesianCS = property(__cartesianCS.value, __cartesianCS.set, None, 'gml:cartesianCS is an association role to the Cartesian coordinate system used by this CRS.')

    
    # Element {http://www.opengis.net/gml/3.2}affineCS uses Python identifier affineCS
    __affineCS = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'affineCS'), 'affineCS', '__httpwww_opengis_netgml3_2_ImageCRSType_httpwww_opengis_netgml3_2affineCS', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateReferenceSystems.xsd', 317, 1), )

    
    affineCS = property(__affineCS.value, __affineCS.set, None, 'gml:affineCS is an association role to the affine coordinate system used by this CRS.')

    
    # Element {http://www.opengis.net/gml/3.2}imageDatum uses Python identifier imageDatum
    __imageDatum = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'imageDatum'), 'imageDatum', '__httpwww_opengis_netgml3_2_ImageCRSType_httpwww_opengis_netgml3_2imageDatum', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateReferenceSystems.xsd', 322, 1), )

    
    imageDatum = property(__imageDatum.value, __imageDatum.set, None, 'gml:imageDatum is an association role to the image datum used by this CRS.')

    
    # Element {http://www.opengis.net/gml/3.2}usesObliqueCartesianCS uses Python identifier usesObliqueCartesianCS
    __usesObliqueCartesianCS = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'usesObliqueCartesianCS'), 'usesObliqueCartesianCS', '__httpwww_opengis_netgml3_2_ImageCRSType_httpwww_opengis_netgml3_2usesObliqueCartesianCS', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 421, 1), )

    
    usesObliqueCartesianCS = property(__usesObliqueCartesianCS.value, __usesObliqueCartesianCS.set, None, '')

    
    # Element metaDataProperty ({http://www.opengis.net/gml/3.2}metaDataProperty) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element remarks ({http://www.opengis.net/gml/3.2}remarks) inherited from {http://www.opengis.net/gml/3.2}DefinitionType
    
    # Element description ({http://www.opengis.net/gml/3.2}description) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element descriptionReference ({http://www.opengis.net/gml/3.2}descriptionReference) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element name ({http://www.opengis.net/gml/3.2}name) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element identifier ({http://www.opengis.net/gml/3.2}identifier) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element domainOfValidity ({http://www.opengis.net/gml/3.2}domainOfValidity) inherited from {http://www.opengis.net/gml/3.2}AbstractCRSType
    
    # Element scope ({http://www.opengis.net/gml/3.2}scope) inherited from {http://www.opengis.net/gml/3.2}AbstractCRSType
    
    # Attribute id_ inherited from {http://www.opengis.net/gml/3.2}DefinitionBaseType
    _ElementMap.update({
        __cartesianCS.name() : __cartesianCS,
        __affineCS.name() : __affineCS,
        __imageDatum.name() : __imageDatum,
        __usesObliqueCartesianCS.name() : __usesObliqueCartesianCS
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.ImageCRSType = ImageCRSType
_Namespace_gml.addCategoryObject('typeBinding', 'ImageCRSType', ImageCRSType)


# Complex type {http://www.opengis.net/gml/3.2}TemporalCRSType with content type ELEMENT_ONLY
class TemporalCRSType (AbstractCRSType):
    """Complex type {http://www.opengis.net/gml/3.2}TemporalCRSType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'TemporalCRSType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateReferenceSystems.xsd', 341, 1)
    _ElementMap = AbstractCRSType._ElementMap.copy()
    _AttributeMap = AbstractCRSType._AttributeMap.copy()
    # Base type is AbstractCRSType
    
    # Element {http://www.opengis.net/gml/3.2}timeCS uses Python identifier timeCS
    __timeCS = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'timeCS'), 'timeCS', '__httpwww_opengis_netgml3_2_TemporalCRSType_httpwww_opengis_netgml3_2timeCS', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateReferenceSystems.xsd', 354, 1), )

    
    timeCS = property(__timeCS.value, __timeCS.set, None, 'gml:timeCS is an association role to the time coordinate system used by this CRS.')

    
    # Element {http://www.opengis.net/gml/3.2}temporalDatum uses Python identifier temporalDatum
    __temporalDatum = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'temporalDatum'), 'temporalDatum', '__httpwww_opengis_netgml3_2_TemporalCRSType_httpwww_opengis_netgml3_2temporalDatum', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateReferenceSystems.xsd', 359, 1), )

    
    temporalDatum = property(__temporalDatum.value, __temporalDatum.set, None, 'gml:temporalDatum is an association role to the temporal datum used by this CRS.')

    
    # Element {http://www.opengis.net/gml/3.2}usesTemporalCS uses Python identifier usesTemporalCS
    __usesTemporalCS = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'usesTemporalCS'), 'usesTemporalCS', '__httpwww_opengis_netgml3_2_TemporalCRSType_httpwww_opengis_netgml3_2usesTemporalCS', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 436, 1), )

    
    usesTemporalCS = property(__usesTemporalCS.value, __usesTemporalCS.set, None, '')

    
    # Element metaDataProperty ({http://www.opengis.net/gml/3.2}metaDataProperty) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element remarks ({http://www.opengis.net/gml/3.2}remarks) inherited from {http://www.opengis.net/gml/3.2}DefinitionType
    
    # Element description ({http://www.opengis.net/gml/3.2}description) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element descriptionReference ({http://www.opengis.net/gml/3.2}descriptionReference) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element name ({http://www.opengis.net/gml/3.2}name) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element identifier ({http://www.opengis.net/gml/3.2}identifier) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element domainOfValidity ({http://www.opengis.net/gml/3.2}domainOfValidity) inherited from {http://www.opengis.net/gml/3.2}AbstractCRSType
    
    # Element scope ({http://www.opengis.net/gml/3.2}scope) inherited from {http://www.opengis.net/gml/3.2}AbstractCRSType
    
    # Attribute id_ inherited from {http://www.opengis.net/gml/3.2}DefinitionBaseType
    _ElementMap.update({
        __timeCS.name() : __timeCS,
        __temporalDatum.name() : __temporalDatum,
        __usesTemporalCS.name() : __usesTemporalCS
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.TemporalCRSType = TemporalCRSType
_Namespace_gml.addCategoryObject('typeBinding', 'TemporalCRSType', TemporalCRSType)


# Complex type {http://www.opengis.net/gml/3.2}EllipsoidalCSType with content type ELEMENT_ONLY
class EllipsoidalCSType (AbstractCoordinateSystemType):
    """Complex type {http://www.opengis.net/gml/3.2}EllipsoidalCSType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'EllipsoidalCSType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateSystems.xsd', 112, 1)
    _ElementMap = AbstractCoordinateSystemType._ElementMap.copy()
    _AttributeMap = AbstractCoordinateSystemType._AttributeMap.copy()
    # Base type is AbstractCoordinateSystemType
    
    # Element axis ({http://www.opengis.net/gml/3.2}axis) inherited from {http://www.opengis.net/gml/3.2}AbstractCoordinateSystemType
    
    # Element metaDataProperty ({http://www.opengis.net/gml/3.2}metaDataProperty) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element remarks ({http://www.opengis.net/gml/3.2}remarks) inherited from {http://www.opengis.net/gml/3.2}DefinitionType
    
    # Element description ({http://www.opengis.net/gml/3.2}description) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element descriptionReference ({http://www.opengis.net/gml/3.2}descriptionReference) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element name ({http://www.opengis.net/gml/3.2}name) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element identifier ({http://www.opengis.net/gml/3.2}identifier) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Attribute id_ inherited from {http://www.opengis.net/gml/3.2}DefinitionBaseType
    
    # Attribute aggregationType inherited from {http://www.opengis.net/gml/3.2}AbstractCoordinateSystemType
    _ElementMap.update({
        
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.EllipsoidalCSType = EllipsoidalCSType
_Namespace_gml.addCategoryObject('typeBinding', 'EllipsoidalCSType', EllipsoidalCSType)


# Complex type {http://www.opengis.net/gml/3.2}CartesianCSType with content type ELEMENT_ONLY
class CartesianCSType (AbstractCoordinateSystemType):
    """Complex type {http://www.opengis.net/gml/3.2}CartesianCSType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'CartesianCSType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateSystems.xsd', 131, 1)
    _ElementMap = AbstractCoordinateSystemType._ElementMap.copy()
    _AttributeMap = AbstractCoordinateSystemType._AttributeMap.copy()
    # Base type is AbstractCoordinateSystemType
    
    # Element axis ({http://www.opengis.net/gml/3.2}axis) inherited from {http://www.opengis.net/gml/3.2}AbstractCoordinateSystemType
    
    # Element metaDataProperty ({http://www.opengis.net/gml/3.2}metaDataProperty) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element remarks ({http://www.opengis.net/gml/3.2}remarks) inherited from {http://www.opengis.net/gml/3.2}DefinitionType
    
    # Element description ({http://www.opengis.net/gml/3.2}description) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element descriptionReference ({http://www.opengis.net/gml/3.2}descriptionReference) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element name ({http://www.opengis.net/gml/3.2}name) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element identifier ({http://www.opengis.net/gml/3.2}identifier) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Attribute id_ inherited from {http://www.opengis.net/gml/3.2}DefinitionBaseType
    
    # Attribute aggregationType inherited from {http://www.opengis.net/gml/3.2}AbstractCoordinateSystemType
    _ElementMap.update({
        
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.CartesianCSType = CartesianCSType
_Namespace_gml.addCategoryObject('typeBinding', 'CartesianCSType', CartesianCSType)


# Complex type {http://www.opengis.net/gml/3.2}VerticalCSType with content type ELEMENT_ONLY
class VerticalCSType (AbstractCoordinateSystemType):
    """Complex type {http://www.opengis.net/gml/3.2}VerticalCSType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'VerticalCSType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateSystems.xsd', 150, 1)
    _ElementMap = AbstractCoordinateSystemType._ElementMap.copy()
    _AttributeMap = AbstractCoordinateSystemType._AttributeMap.copy()
    # Base type is AbstractCoordinateSystemType
    
    # Element axis ({http://www.opengis.net/gml/3.2}axis) inherited from {http://www.opengis.net/gml/3.2}AbstractCoordinateSystemType
    
    # Element metaDataProperty ({http://www.opengis.net/gml/3.2}metaDataProperty) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element remarks ({http://www.opengis.net/gml/3.2}remarks) inherited from {http://www.opengis.net/gml/3.2}DefinitionType
    
    # Element description ({http://www.opengis.net/gml/3.2}description) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element descriptionReference ({http://www.opengis.net/gml/3.2}descriptionReference) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element name ({http://www.opengis.net/gml/3.2}name) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element identifier ({http://www.opengis.net/gml/3.2}identifier) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Attribute id_ inherited from {http://www.opengis.net/gml/3.2}DefinitionBaseType
    
    # Attribute aggregationType inherited from {http://www.opengis.net/gml/3.2}AbstractCoordinateSystemType
    _ElementMap.update({
        
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.VerticalCSType = VerticalCSType
_Namespace_gml.addCategoryObject('typeBinding', 'VerticalCSType', VerticalCSType)


# Complex type {http://www.opengis.net/gml/3.2}TimeCSType with content type ELEMENT_ONLY
class TimeCSType (AbstractCoordinateSystemType):
    """Complex type {http://www.opengis.net/gml/3.2}TimeCSType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'TimeCSType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateSystems.xsd', 169, 1)
    _ElementMap = AbstractCoordinateSystemType._ElementMap.copy()
    _AttributeMap = AbstractCoordinateSystemType._AttributeMap.copy()
    # Base type is AbstractCoordinateSystemType
    
    # Element axis ({http://www.opengis.net/gml/3.2}axis) inherited from {http://www.opengis.net/gml/3.2}AbstractCoordinateSystemType
    
    # Element metaDataProperty ({http://www.opengis.net/gml/3.2}metaDataProperty) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element remarks ({http://www.opengis.net/gml/3.2}remarks) inherited from {http://www.opengis.net/gml/3.2}DefinitionType
    
    # Element description ({http://www.opengis.net/gml/3.2}description) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element descriptionReference ({http://www.opengis.net/gml/3.2}descriptionReference) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element name ({http://www.opengis.net/gml/3.2}name) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element identifier ({http://www.opengis.net/gml/3.2}identifier) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Attribute id_ inherited from {http://www.opengis.net/gml/3.2}DefinitionBaseType
    
    # Attribute aggregationType inherited from {http://www.opengis.net/gml/3.2}AbstractCoordinateSystemType
    _ElementMap.update({
        
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.TimeCSType = TimeCSType
_Namespace_gml.addCategoryObject('typeBinding', 'TimeCSType', TimeCSType)


# Complex type {http://www.opengis.net/gml/3.2}LinearCSType with content type ELEMENT_ONLY
class LinearCSType (AbstractCoordinateSystemType):
    """Complex type {http://www.opengis.net/gml/3.2}LinearCSType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'LinearCSType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateSystems.xsd', 188, 1)
    _ElementMap = AbstractCoordinateSystemType._ElementMap.copy()
    _AttributeMap = AbstractCoordinateSystemType._AttributeMap.copy()
    # Base type is AbstractCoordinateSystemType
    
    # Element axis ({http://www.opengis.net/gml/3.2}axis) inherited from {http://www.opengis.net/gml/3.2}AbstractCoordinateSystemType
    
    # Element metaDataProperty ({http://www.opengis.net/gml/3.2}metaDataProperty) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element remarks ({http://www.opengis.net/gml/3.2}remarks) inherited from {http://www.opengis.net/gml/3.2}DefinitionType
    
    # Element description ({http://www.opengis.net/gml/3.2}description) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element descriptionReference ({http://www.opengis.net/gml/3.2}descriptionReference) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element name ({http://www.opengis.net/gml/3.2}name) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element identifier ({http://www.opengis.net/gml/3.2}identifier) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Attribute id_ inherited from {http://www.opengis.net/gml/3.2}DefinitionBaseType
    
    # Attribute aggregationType inherited from {http://www.opengis.net/gml/3.2}AbstractCoordinateSystemType
    _ElementMap.update({
        
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.LinearCSType = LinearCSType
_Namespace_gml.addCategoryObject('typeBinding', 'LinearCSType', LinearCSType)


# Complex type {http://www.opengis.net/gml/3.2}UserDefinedCSType with content type ELEMENT_ONLY
class UserDefinedCSType (AbstractCoordinateSystemType):
    """Complex type {http://www.opengis.net/gml/3.2}UserDefinedCSType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'UserDefinedCSType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateSystems.xsd', 207, 1)
    _ElementMap = AbstractCoordinateSystemType._ElementMap.copy()
    _AttributeMap = AbstractCoordinateSystemType._AttributeMap.copy()
    # Base type is AbstractCoordinateSystemType
    
    # Element axis ({http://www.opengis.net/gml/3.2}axis) inherited from {http://www.opengis.net/gml/3.2}AbstractCoordinateSystemType
    
    # Element metaDataProperty ({http://www.opengis.net/gml/3.2}metaDataProperty) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element remarks ({http://www.opengis.net/gml/3.2}remarks) inherited from {http://www.opengis.net/gml/3.2}DefinitionType
    
    # Element description ({http://www.opengis.net/gml/3.2}description) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element descriptionReference ({http://www.opengis.net/gml/3.2}descriptionReference) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element name ({http://www.opengis.net/gml/3.2}name) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element identifier ({http://www.opengis.net/gml/3.2}identifier) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Attribute id_ inherited from {http://www.opengis.net/gml/3.2}DefinitionBaseType
    
    # Attribute aggregationType inherited from {http://www.opengis.net/gml/3.2}AbstractCoordinateSystemType
    _ElementMap.update({
        
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.UserDefinedCSType = UserDefinedCSType
_Namespace_gml.addCategoryObject('typeBinding', 'UserDefinedCSType', UserDefinedCSType)


# Complex type {http://www.opengis.net/gml/3.2}SphericalCSType with content type ELEMENT_ONLY
class SphericalCSType (AbstractCoordinateSystemType):
    """Complex type {http://www.opengis.net/gml/3.2}SphericalCSType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'SphericalCSType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateSystems.xsd', 226, 1)
    _ElementMap = AbstractCoordinateSystemType._ElementMap.copy()
    _AttributeMap = AbstractCoordinateSystemType._AttributeMap.copy()
    # Base type is AbstractCoordinateSystemType
    
    # Element axis ({http://www.opengis.net/gml/3.2}axis) inherited from {http://www.opengis.net/gml/3.2}AbstractCoordinateSystemType
    
    # Element metaDataProperty ({http://www.opengis.net/gml/3.2}metaDataProperty) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element remarks ({http://www.opengis.net/gml/3.2}remarks) inherited from {http://www.opengis.net/gml/3.2}DefinitionType
    
    # Element description ({http://www.opengis.net/gml/3.2}description) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element descriptionReference ({http://www.opengis.net/gml/3.2}descriptionReference) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element name ({http://www.opengis.net/gml/3.2}name) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element identifier ({http://www.opengis.net/gml/3.2}identifier) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Attribute id_ inherited from {http://www.opengis.net/gml/3.2}DefinitionBaseType
    
    # Attribute aggregationType inherited from {http://www.opengis.net/gml/3.2}AbstractCoordinateSystemType
    _ElementMap.update({
        
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.SphericalCSType = SphericalCSType
_Namespace_gml.addCategoryObject('typeBinding', 'SphericalCSType', SphericalCSType)


# Complex type {http://www.opengis.net/gml/3.2}PolarCSType with content type ELEMENT_ONLY
class PolarCSType (AbstractCoordinateSystemType):
    """Complex type {http://www.opengis.net/gml/3.2}PolarCSType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'PolarCSType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateSystems.xsd', 245, 1)
    _ElementMap = AbstractCoordinateSystemType._ElementMap.copy()
    _AttributeMap = AbstractCoordinateSystemType._AttributeMap.copy()
    # Base type is AbstractCoordinateSystemType
    
    # Element axis ({http://www.opengis.net/gml/3.2}axis) inherited from {http://www.opengis.net/gml/3.2}AbstractCoordinateSystemType
    
    # Element metaDataProperty ({http://www.opengis.net/gml/3.2}metaDataProperty) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element remarks ({http://www.opengis.net/gml/3.2}remarks) inherited from {http://www.opengis.net/gml/3.2}DefinitionType
    
    # Element description ({http://www.opengis.net/gml/3.2}description) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element descriptionReference ({http://www.opengis.net/gml/3.2}descriptionReference) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element name ({http://www.opengis.net/gml/3.2}name) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element identifier ({http://www.opengis.net/gml/3.2}identifier) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Attribute id_ inherited from {http://www.opengis.net/gml/3.2}DefinitionBaseType
    
    # Attribute aggregationType inherited from {http://www.opengis.net/gml/3.2}AbstractCoordinateSystemType
    _ElementMap.update({
        
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.PolarCSType = PolarCSType
_Namespace_gml.addCategoryObject('typeBinding', 'PolarCSType', PolarCSType)


# Complex type {http://www.opengis.net/gml/3.2}CylindricalCSType with content type ELEMENT_ONLY
class CylindricalCSType (AbstractCoordinateSystemType):
    """Complex type {http://www.opengis.net/gml/3.2}CylindricalCSType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'CylindricalCSType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateSystems.xsd', 264, 1)
    _ElementMap = AbstractCoordinateSystemType._ElementMap.copy()
    _AttributeMap = AbstractCoordinateSystemType._AttributeMap.copy()
    # Base type is AbstractCoordinateSystemType
    
    # Element axis ({http://www.opengis.net/gml/3.2}axis) inherited from {http://www.opengis.net/gml/3.2}AbstractCoordinateSystemType
    
    # Element metaDataProperty ({http://www.opengis.net/gml/3.2}metaDataProperty) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element remarks ({http://www.opengis.net/gml/3.2}remarks) inherited from {http://www.opengis.net/gml/3.2}DefinitionType
    
    # Element description ({http://www.opengis.net/gml/3.2}description) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element descriptionReference ({http://www.opengis.net/gml/3.2}descriptionReference) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element name ({http://www.opengis.net/gml/3.2}name) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element identifier ({http://www.opengis.net/gml/3.2}identifier) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Attribute id_ inherited from {http://www.opengis.net/gml/3.2}DefinitionBaseType
    
    # Attribute aggregationType inherited from {http://www.opengis.net/gml/3.2}AbstractCoordinateSystemType
    _ElementMap.update({
        
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.CylindricalCSType = CylindricalCSType
_Namespace_gml.addCategoryObject('typeBinding', 'CylindricalCSType', CylindricalCSType)


# Complex type {http://www.opengis.net/gml/3.2}AffineCSType with content type ELEMENT_ONLY
class AffineCSType (AbstractCoordinateSystemType):
    """Complex type {http://www.opengis.net/gml/3.2}AffineCSType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'AffineCSType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateSystems.xsd', 283, 1)
    _ElementMap = AbstractCoordinateSystemType._ElementMap.copy()
    _AttributeMap = AbstractCoordinateSystemType._AttributeMap.copy()
    # Base type is AbstractCoordinateSystemType
    
    # Element axis ({http://www.opengis.net/gml/3.2}axis) inherited from {http://www.opengis.net/gml/3.2}AbstractCoordinateSystemType
    
    # Element metaDataProperty ({http://www.opengis.net/gml/3.2}metaDataProperty) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element remarks ({http://www.opengis.net/gml/3.2}remarks) inherited from {http://www.opengis.net/gml/3.2}DefinitionType
    
    # Element description ({http://www.opengis.net/gml/3.2}description) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element descriptionReference ({http://www.opengis.net/gml/3.2}descriptionReference) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element name ({http://www.opengis.net/gml/3.2}name) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element identifier ({http://www.opengis.net/gml/3.2}identifier) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Attribute id_ inherited from {http://www.opengis.net/gml/3.2}DefinitionBaseType
    
    # Attribute aggregationType inherited from {http://www.opengis.net/gml/3.2}AbstractCoordinateSystemType
    _ElementMap.update({
        
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.AffineCSType = AffineCSType
_Namespace_gml.addCategoryObject('typeBinding', 'AffineCSType', AffineCSType)


# Complex type {http://www.opengis.net/gml/3.2}GeodeticDatumType with content type ELEMENT_ONLY
class GeodeticDatumType (AbstractDatumType):
    """Complex type {http://www.opengis.net/gml/3.2}GeodeticDatumType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'GeodeticDatumType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/datums.xsd', 66, 1)
    _ElementMap = AbstractDatumType._ElementMap.copy()
    _AttributeMap = AbstractDatumType._AttributeMap.copy()
    # Base type is AbstractDatumType
    
    # Element anchorDefinition ({http://www.opengis.net/gml/3.2}anchorDefinition) inherited from {http://www.opengis.net/gml/3.2}AbstractDatumType
    
    # Element realizationEpoch ({http://www.opengis.net/gml/3.2}realizationEpoch) inherited from {http://www.opengis.net/gml/3.2}AbstractDatumType
    
    # Element {http://www.opengis.net/gml/3.2}primeMeridian uses Python identifier primeMeridian
    __primeMeridian = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'primeMeridian'), 'primeMeridian', '__httpwww_opengis_netgml3_2_GeodeticDatumType_httpwww_opengis_netgml3_2primeMeridian', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/datums.xsd', 76, 1), )

    
    primeMeridian = property(__primeMeridian.value, __primeMeridian.set, None, 'gml:primeMeridian is an association role to the prime meridian used by this geodetic datum.')

    
    # Element {http://www.opengis.net/gml/3.2}ellipsoid uses Python identifier ellipsoid
    __ellipsoid = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'ellipsoid'), 'ellipsoid', '__httpwww_opengis_netgml3_2_GeodeticDatumType_httpwww_opengis_netgml3_2ellipsoid', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/datums.xsd', 81, 1), )

    
    ellipsoid = property(__ellipsoid.value, __ellipsoid.set, None, 'gml:ellipsoid is an association role to the ellipsoid used by this geodetic datum.')

    
    # Element metaDataProperty ({http://www.opengis.net/gml/3.2}metaDataProperty) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element remarks ({http://www.opengis.net/gml/3.2}remarks) inherited from {http://www.opengis.net/gml/3.2}DefinitionType
    
    # Element description ({http://www.opengis.net/gml/3.2}description) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element descriptionReference ({http://www.opengis.net/gml/3.2}descriptionReference) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element name ({http://www.opengis.net/gml/3.2}name) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element identifier ({http://www.opengis.net/gml/3.2}identifier) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element domainOfValidity ({http://www.opengis.net/gml/3.2}domainOfValidity) inherited from {http://www.opengis.net/gml/3.2}AbstractDatumType
    
    # Element scope ({http://www.opengis.net/gml/3.2}scope) inherited from {http://www.opengis.net/gml/3.2}AbstractDatumType
    
    # Attribute id_ inherited from {http://www.opengis.net/gml/3.2}DefinitionBaseType
    _ElementMap.update({
        __primeMeridian.name() : __primeMeridian,
        __ellipsoid.name() : __ellipsoid
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.GeodeticDatumType = GeodeticDatumType
_Namespace_gml.addCategoryObject('typeBinding', 'GeodeticDatumType', GeodeticDatumType)


# Complex type {http://www.opengis.net/gml/3.2}EngineeringDatumType with content type ELEMENT_ONLY
class EngineeringDatumType (AbstractDatumType):
    """Complex type {http://www.opengis.net/gml/3.2}EngineeringDatumType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'EngineeringDatumType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/datums.xsd', 178, 1)
    _ElementMap = AbstractDatumType._ElementMap.copy()
    _AttributeMap = AbstractDatumType._AttributeMap.copy()
    # Base type is AbstractDatumType
    
    # Element anchorDefinition ({http://www.opengis.net/gml/3.2}anchorDefinition) inherited from {http://www.opengis.net/gml/3.2}AbstractDatumType
    
    # Element realizationEpoch ({http://www.opengis.net/gml/3.2}realizationEpoch) inherited from {http://www.opengis.net/gml/3.2}AbstractDatumType
    
    # Element metaDataProperty ({http://www.opengis.net/gml/3.2}metaDataProperty) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element remarks ({http://www.opengis.net/gml/3.2}remarks) inherited from {http://www.opengis.net/gml/3.2}DefinitionType
    
    # Element description ({http://www.opengis.net/gml/3.2}description) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element descriptionReference ({http://www.opengis.net/gml/3.2}descriptionReference) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element name ({http://www.opengis.net/gml/3.2}name) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element identifier ({http://www.opengis.net/gml/3.2}identifier) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element domainOfValidity ({http://www.opengis.net/gml/3.2}domainOfValidity) inherited from {http://www.opengis.net/gml/3.2}AbstractDatumType
    
    # Element scope ({http://www.opengis.net/gml/3.2}scope) inherited from {http://www.opengis.net/gml/3.2}AbstractDatumType
    
    # Attribute id_ inherited from {http://www.opengis.net/gml/3.2}DefinitionBaseType
    _ElementMap.update({
        
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.EngineeringDatumType = EngineeringDatumType
_Namespace_gml.addCategoryObject('typeBinding', 'EngineeringDatumType', EngineeringDatumType)


# Complex type {http://www.opengis.net/gml/3.2}ImageDatumType with content type ELEMENT_ONLY
class ImageDatumType (AbstractDatumType):
    """Complex type {http://www.opengis.net/gml/3.2}ImageDatumType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'ImageDatumType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/datums.xsd', 197, 1)
    _ElementMap = AbstractDatumType._ElementMap.copy()
    _AttributeMap = AbstractDatumType._AttributeMap.copy()
    # Base type is AbstractDatumType
    
    # Element anchorDefinition ({http://www.opengis.net/gml/3.2}anchorDefinition) inherited from {http://www.opengis.net/gml/3.2}AbstractDatumType
    
    # Element realizationEpoch ({http://www.opengis.net/gml/3.2}realizationEpoch) inherited from {http://www.opengis.net/gml/3.2}AbstractDatumType
    
    # Element {http://www.opengis.net/gml/3.2}pixelInCell uses Python identifier pixelInCell
    __pixelInCell = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'pixelInCell'), 'pixelInCell', '__httpwww_opengis_netgml3_2_ImageDatumType_httpwww_opengis_netgml3_2pixelInCell', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/datums.xsd', 206, 1), )

    
    pixelInCell = property(__pixelInCell.value, __pixelInCell.set, None, 'gml:pixelInCell is a specification of the way an image grid is associated with the image data attributes. The required codeSpace attribute shall reference a source of information specifying the values and meanings of all the allowed string values for this property.')

    
    # Element metaDataProperty ({http://www.opengis.net/gml/3.2}metaDataProperty) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element remarks ({http://www.opengis.net/gml/3.2}remarks) inherited from {http://www.opengis.net/gml/3.2}DefinitionType
    
    # Element description ({http://www.opengis.net/gml/3.2}description) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element descriptionReference ({http://www.opengis.net/gml/3.2}descriptionReference) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element name ({http://www.opengis.net/gml/3.2}name) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element identifier ({http://www.opengis.net/gml/3.2}identifier) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element domainOfValidity ({http://www.opengis.net/gml/3.2}domainOfValidity) inherited from {http://www.opengis.net/gml/3.2}AbstractDatumType
    
    # Element scope ({http://www.opengis.net/gml/3.2}scope) inherited from {http://www.opengis.net/gml/3.2}AbstractDatumType
    
    # Attribute id_ inherited from {http://www.opengis.net/gml/3.2}DefinitionBaseType
    _ElementMap.update({
        __pixelInCell.name() : __pixelInCell
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.ImageDatumType = ImageDatumType
_Namespace_gml.addCategoryObject('typeBinding', 'ImageDatumType', ImageDatumType)


# Complex type {http://www.opengis.net/gml/3.2}VerticalDatumType with content type ELEMENT_ONLY
class VerticalDatumType (AbstractDatumType):
    """Complex type {http://www.opengis.net/gml/3.2}VerticalDatumType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'VerticalDatumType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/datums.xsd', 225, 1)
    _ElementMap = AbstractDatumType._ElementMap.copy()
    _AttributeMap = AbstractDatumType._AttributeMap.copy()
    # Base type is AbstractDatumType
    
    # Element anchorDefinition ({http://www.opengis.net/gml/3.2}anchorDefinition) inherited from {http://www.opengis.net/gml/3.2}AbstractDatumType
    
    # Element realizationEpoch ({http://www.opengis.net/gml/3.2}realizationEpoch) inherited from {http://www.opengis.net/gml/3.2}AbstractDatumType
    
    # Element metaDataProperty ({http://www.opengis.net/gml/3.2}metaDataProperty) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element remarks ({http://www.opengis.net/gml/3.2}remarks) inherited from {http://www.opengis.net/gml/3.2}DefinitionType
    
    # Element description ({http://www.opengis.net/gml/3.2}description) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element descriptionReference ({http://www.opengis.net/gml/3.2}descriptionReference) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element name ({http://www.opengis.net/gml/3.2}name) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element identifier ({http://www.opengis.net/gml/3.2}identifier) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element domainOfValidity ({http://www.opengis.net/gml/3.2}domainOfValidity) inherited from {http://www.opengis.net/gml/3.2}AbstractDatumType
    
    # Element scope ({http://www.opengis.net/gml/3.2}scope) inherited from {http://www.opengis.net/gml/3.2}AbstractDatumType
    
    # Attribute id_ inherited from {http://www.opengis.net/gml/3.2}DefinitionBaseType
    _ElementMap.update({
        
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.VerticalDatumType = VerticalDatumType
_Namespace_gml.addCategoryObject('typeBinding', 'VerticalDatumType', VerticalDatumType)


# Complex type {http://www.opengis.net/gml/3.2}TemporalDatumBaseType with content type ELEMENT_ONLY
class TemporalDatumBaseType (AbstractDatumType):
    """The TemporalDatumBaseType partially defines the origin of a temporal coordinate reference system. This type restricts the AbstractDatumType to remove the "anchorDefinition" and "realizationEpoch" elements."""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = True
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'TemporalDatumBaseType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/datums.xsd', 253, 1)
    _ElementMap = AbstractDatumType._ElementMap.copy()
    _AttributeMap = AbstractDatumType._AttributeMap.copy()
    # Base type is AbstractDatumType
    
    # Element metaDataProperty ({http://www.opengis.net/gml/3.2}metaDataProperty) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element remarks ({http://www.opengis.net/gml/3.2}remarks) inherited from {http://www.opengis.net/gml/3.2}DefinitionType
    
    # Element description ({http://www.opengis.net/gml/3.2}description) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element descriptionReference ({http://www.opengis.net/gml/3.2}descriptionReference) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element name ({http://www.opengis.net/gml/3.2}name) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element identifier ({http://www.opengis.net/gml/3.2}identifier) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element domainOfValidity ({http://www.opengis.net/gml/3.2}domainOfValidity) inherited from {http://www.opengis.net/gml/3.2}AbstractDatumType
    
    # Element scope ({http://www.opengis.net/gml/3.2}scope) inherited from {http://www.opengis.net/gml/3.2}AbstractDatumType
    
    # Attribute id is restricted from parent
    
    # Attribute {http://www.opengis.net/gml/3.2}id uses Python identifier id
    __id = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(_Namespace_gml, 'id'), 'id', '__httpwww_opengis_netgml3_2_AbstractGMLType_httpwww_opengis_netgml3_2id', pyxb.binding.datatypes.ID, required=True)
    __id._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 137, 1)
    __id._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/datums.xsd', 269, 4)
    
    id = property(__id.value, __id.set, None, 'The attribute gml:id supports provision of a handle for the XML element representing a GML Object. Its use is mandatory for all GML objects. It is of XML type ID, so is constrained to be unique in the XML document within which it occurs.')

    _ElementMap.update({
        
    })
    _AttributeMap.update({
        __id.name() : __id
    })
_module_typeBindings.TemporalDatumBaseType = TemporalDatumBaseType
_Namespace_gml.addCategoryObject('typeBinding', 'TemporalDatumBaseType', TemporalDatumBaseType)


# Complex type {http://www.opengis.net/gml/3.2}TemporalCSType with content type ELEMENT_ONLY
class TemporalCSType (AbstractCoordinateSystemType):
    """"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'TemporalCSType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 252, 1)
    _ElementMap = AbstractCoordinateSystemType._ElementMap.copy()
    _AttributeMap = AbstractCoordinateSystemType._AttributeMap.copy()
    # Base type is AbstractCoordinateSystemType
    
    # Element axis ({http://www.opengis.net/gml/3.2}axis) inherited from {http://www.opengis.net/gml/3.2}AbstractCoordinateSystemType
    
    # Element metaDataProperty ({http://www.opengis.net/gml/3.2}metaDataProperty) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element remarks ({http://www.opengis.net/gml/3.2}remarks) inherited from {http://www.opengis.net/gml/3.2}DefinitionType
    
    # Element description ({http://www.opengis.net/gml/3.2}description) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element descriptionReference ({http://www.opengis.net/gml/3.2}descriptionReference) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element name ({http://www.opengis.net/gml/3.2}name) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element identifier ({http://www.opengis.net/gml/3.2}identifier) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Attribute id_ inherited from {http://www.opengis.net/gml/3.2}DefinitionBaseType
    
    # Attribute aggregationType inherited from {http://www.opengis.net/gml/3.2}AbstractCoordinateSystemType
    _ElementMap.update({
        
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.TemporalCSType = TemporalCSType
_Namespace_gml.addCategoryObject('typeBinding', 'TemporalCSType', TemporalCSType)


# Complex type {http://www.opengis.net/gml/3.2}ObliqueCartesianCSType with content type ELEMENT_ONLY
class ObliqueCartesianCSType (AbstractCoordinateSystemType):
    """"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'ObliqueCartesianCSType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 304, 1)
    _ElementMap = AbstractCoordinateSystemType._ElementMap.copy()
    _AttributeMap = AbstractCoordinateSystemType._AttributeMap.copy()
    # Base type is AbstractCoordinateSystemType
    
    # Element axis ({http://www.opengis.net/gml/3.2}axis) inherited from {http://www.opengis.net/gml/3.2}AbstractCoordinateSystemType
    
    # Element metaDataProperty ({http://www.opengis.net/gml/3.2}metaDataProperty) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element remarks ({http://www.opengis.net/gml/3.2}remarks) inherited from {http://www.opengis.net/gml/3.2}DefinitionType
    
    # Element description ({http://www.opengis.net/gml/3.2}description) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element descriptionReference ({http://www.opengis.net/gml/3.2}descriptionReference) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element name ({http://www.opengis.net/gml/3.2}name) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element identifier ({http://www.opengis.net/gml/3.2}identifier) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Attribute id_ inherited from {http://www.opengis.net/gml/3.2}DefinitionBaseType
    
    # Attribute aggregationType inherited from {http://www.opengis.net/gml/3.2}AbstractCoordinateSystemType
    _ElementMap.update({
        
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.ObliqueCartesianCSType = ObliqueCartesianCSType
_Namespace_gml.addCategoryObject('typeBinding', 'ObliqueCartesianCSType', ObliqueCartesianCSType)


# Complex type {http://www.opengis.net/gml/3.2}GeographicCRSType with content type ELEMENT_ONLY
class GeographicCRSType (AbstractCRSType):
    """"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'GeographicCRSType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 456, 1)
    _ElementMap = AbstractCRSType._ElementMap.copy()
    _AttributeMap = AbstractCRSType._AttributeMap.copy()
    # Base type is AbstractCRSType
    
    # Element {http://www.opengis.net/gml/3.2}usesEllipsoidalCS uses Python identifier usesEllipsoidalCS
    __usesEllipsoidalCS = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'usesEllipsoidalCS'), 'usesEllipsoidalCS', '__httpwww_opengis_netgml3_2_GeographicCRSType_httpwww_opengis_netgml3_2usesEllipsoidalCS', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 346, 1), )

    
    usesEllipsoidalCS = property(__usesEllipsoidalCS.value, __usesEllipsoidalCS.set, None, '')

    
    # Element {http://www.opengis.net/gml/3.2}usesGeodeticDatum uses Python identifier usesGeodeticDatum
    __usesGeodeticDatum = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'usesGeodeticDatum'), 'usesGeodeticDatum', '__httpwww_opengis_netgml3_2_GeographicCRSType_httpwww_opengis_netgml3_2usesGeodeticDatum', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 361, 1), )

    
    usesGeodeticDatum = property(__usesGeodeticDatum.value, __usesGeodeticDatum.set, None, '')

    
    # Element metaDataProperty ({http://www.opengis.net/gml/3.2}metaDataProperty) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element remarks ({http://www.opengis.net/gml/3.2}remarks) inherited from {http://www.opengis.net/gml/3.2}DefinitionType
    
    # Element description ({http://www.opengis.net/gml/3.2}description) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element descriptionReference ({http://www.opengis.net/gml/3.2}descriptionReference) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element name ({http://www.opengis.net/gml/3.2}name) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element identifier ({http://www.opengis.net/gml/3.2}identifier) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element domainOfValidity ({http://www.opengis.net/gml/3.2}domainOfValidity) inherited from {http://www.opengis.net/gml/3.2}AbstractCRSType
    
    # Element scope ({http://www.opengis.net/gml/3.2}scope) inherited from {http://www.opengis.net/gml/3.2}AbstractCRSType
    
    # Attribute id_ inherited from {http://www.opengis.net/gml/3.2}DefinitionBaseType
    _ElementMap.update({
        __usesEllipsoidalCS.name() : __usesEllipsoidalCS,
        __usesGeodeticDatum.name() : __usesGeodeticDatum
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.GeographicCRSType = GeographicCRSType
_Namespace_gml.addCategoryObject('typeBinding', 'GeographicCRSType', GeographicCRSType)


# Complex type {http://www.opengis.net/gml/3.2}GeocentricCRSType with content type ELEMENT_ONLY
class GeocentricCRSType (AbstractCRSType):
    """"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'GeocentricCRSType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 488, 1)
    _ElementMap = AbstractCRSType._ElementMap.copy()
    _AttributeMap = AbstractCRSType._AttributeMap.copy()
    # Base type is AbstractCRSType
    
    # Element {http://www.opengis.net/gml/3.2}usesCartesianCS uses Python identifier usesCartesianCS
    __usesCartesianCS = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'usesCartesianCS'), 'usesCartesianCS', '__httpwww_opengis_netgml3_2_GeocentricCRSType_httpwww_opengis_netgml3_2usesCartesianCS', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 351, 1), )

    
    usesCartesianCS = property(__usesCartesianCS.value, __usesCartesianCS.set, None, '')

    
    # Element {http://www.opengis.net/gml/3.2}usesSphericalCS uses Python identifier usesSphericalCS
    __usesSphericalCS = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'usesSphericalCS'), 'usesSphericalCS', '__httpwww_opengis_netgml3_2_GeocentricCRSType_httpwww_opengis_netgml3_2usesSphericalCS', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 356, 1), )

    
    usesSphericalCS = property(__usesSphericalCS.value, __usesSphericalCS.set, None, '')

    
    # Element {http://www.opengis.net/gml/3.2}usesGeodeticDatum uses Python identifier usesGeodeticDatum
    __usesGeodeticDatum = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'usesGeodeticDatum'), 'usesGeodeticDatum', '__httpwww_opengis_netgml3_2_GeocentricCRSType_httpwww_opengis_netgml3_2usesGeodeticDatum', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 361, 1), )

    
    usesGeodeticDatum = property(__usesGeodeticDatum.value, __usesGeodeticDatum.set, None, '')

    
    # Element metaDataProperty ({http://www.opengis.net/gml/3.2}metaDataProperty) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element remarks ({http://www.opengis.net/gml/3.2}remarks) inherited from {http://www.opengis.net/gml/3.2}DefinitionType
    
    # Element description ({http://www.opengis.net/gml/3.2}description) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element descriptionReference ({http://www.opengis.net/gml/3.2}descriptionReference) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element name ({http://www.opengis.net/gml/3.2}name) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element identifier ({http://www.opengis.net/gml/3.2}identifier) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element domainOfValidity ({http://www.opengis.net/gml/3.2}domainOfValidity) inherited from {http://www.opengis.net/gml/3.2}AbstractCRSType
    
    # Element scope ({http://www.opengis.net/gml/3.2}scope) inherited from {http://www.opengis.net/gml/3.2}AbstractCRSType
    
    # Attribute id_ inherited from {http://www.opengis.net/gml/3.2}DefinitionBaseType
    _ElementMap.update({
        __usesCartesianCS.name() : __usesCartesianCS,
        __usesSphericalCS.name() : __usesSphericalCS,
        __usesGeodeticDatum.name() : __usesGeodeticDatum
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.GeocentricCRSType = GeocentricCRSType
_Namespace_gml.addCategoryObject('typeBinding', 'GeocentricCRSType', GeocentricCRSType)


# Complex type {http://www.opengis.net/gml/3.2}LinearRingType with content type ELEMENT_ONLY
class LinearRingType (AbstractRingType):
    """Complex type {http://www.opengis.net/gml/3.2}LinearRingType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'LinearRingType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic2d.xsd', 98, 1)
    _ElementMap = AbstractRingType._ElementMap.copy()
    _AttributeMap = AbstractRingType._AttributeMap.copy()
    # Base type is AbstractRingType
    
    # Element metaDataProperty ({http://www.opengis.net/gml/3.2}metaDataProperty) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element {http://www.opengis.net/gml/3.2}coordinates uses Python identifier coordinates
    __coordinates = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'coordinates'), 'coordinates', '__httpwww_opengis_netgml3_2_LinearRingType_httpwww_opengis_netgml3_2coordinates', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 751, 1), )

    
    coordinates = property(__coordinates.value, __coordinates.set, None, '')

    
    # Element {http://www.opengis.net/gml/3.2}pointRep uses Python identifier pointRep
    __pointRep = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'pointRep'), 'pointRep', '__httpwww_opengis_netgml3_2_LinearRingType_httpwww_opengis_netgml3_2pointRep', True, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 756, 1), )

    
    pointRep = property(__pointRep.value, __pointRep.set, None, '')

    
    # Element {http://www.opengis.net/gml/3.2}pos uses Python identifier pos
    __pos = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'pos'), 'pos', '__httpwww_opengis_netgml3_2_LinearRingType_httpwww_opengis_netgml3_2pos', True, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic0d1d.xsd', 87, 1), )

    
    pos = property(__pos.value, __pos.set, None, None)

    
    # Element {http://www.opengis.net/gml/3.2}posList uses Python identifier posList
    __posList = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'posList'), 'posList', '__httpwww_opengis_netgml3_2_LinearRingType_httpwww_opengis_netgml3_2posList', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic0d1d.xsd', 102, 1), )

    
    posList = property(__posList.value, __posList.set, None, None)

    
    # Element {http://www.opengis.net/gml/3.2}pointProperty uses Python identifier pointProperty
    __pointProperty = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'pointProperty'), 'pointProperty', '__httpwww_opengis_netgml3_2_LinearRingType_httpwww_opengis_netgml3_2pointProperty', True, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic0d1d.xsd', 204, 1), )

    
    pointProperty = property(__pointProperty.value, __pointProperty.set, None, 'This property element either references a point via the XLink-attributes or contains the point element. pointProperty is the predefined property which may be used by GML Application Schemas whenever a GML feature has a property with a value that is substitutable for Point.')

    
    # Element description ({http://www.opengis.net/gml/3.2}description) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element descriptionReference ({http://www.opengis.net/gml/3.2}descriptionReference) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element name ({http://www.opengis.net/gml/3.2}name) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element identifier ({http://www.opengis.net/gml/3.2}identifier) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Attribute srsName inherited from {http://www.opengis.net/gml/3.2}AbstractGeometryType
    
    # Attribute srsDimension inherited from {http://www.opengis.net/gml/3.2}AbstractGeometryType
    
    # Attribute axisLabels inherited from {http://www.opengis.net/gml/3.2}AbstractGeometryType
    
    # Attribute uomLabels inherited from {http://www.opengis.net/gml/3.2}AbstractGeometryType
    
    # Attribute id inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    _ElementMap.update({
        __coordinates.name() : __coordinates,
        __pointRep.name() : __pointRep,
        __pos.name() : __pos,
        __posList.name() : __posList,
        __pointProperty.name() : __pointProperty
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.LinearRingType = LinearRingType
_Namespace_gml.addCategoryObject('typeBinding', 'LinearRingType', LinearRingType)


# Complex type {http://www.opengis.net/gml/3.2}RingType with content type ELEMENT_ONLY
class RingType (AbstractRingType):
    """Complex type {http://www.opengis.net/gml/3.2}RingType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'RingType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 622, 1)
    _ElementMap = AbstractRingType._ElementMap.copy()
    _AttributeMap = AbstractRingType._AttributeMap.copy()
    # Base type is AbstractRingType
    
    # Element metaDataProperty ({http://www.opengis.net/gml/3.2}metaDataProperty) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element {http://www.opengis.net/gml/3.2}curveMember uses Python identifier curveMember
    __curveMember = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'curveMember'), 'curveMember', '__httpwww_opengis_netgml3_2_RingType_httpwww_opengis_netgml3_2curveMember', True, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 639, 1), )

    
    curveMember = property(__curveMember.value, __curveMember.set, None, None)

    
    # Element description ({http://www.opengis.net/gml/3.2}description) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element descriptionReference ({http://www.opengis.net/gml/3.2}descriptionReference) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element name ({http://www.opengis.net/gml/3.2}name) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element identifier ({http://www.opengis.net/gml/3.2}identifier) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Attribute srsName inherited from {http://www.opengis.net/gml/3.2}AbstractGeometryType
    
    # Attribute srsDimension inherited from {http://www.opengis.net/gml/3.2}AbstractGeometryType
    
    # Attribute axisLabels inherited from {http://www.opengis.net/gml/3.2}AbstractGeometryType
    
    # Attribute uomLabels inherited from {http://www.opengis.net/gml/3.2}AbstractGeometryType
    
    # Attribute id inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Attribute aggregationType uses Python identifier aggregationType
    __aggregationType = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'aggregationType'), 'aggregationType', '__httpwww_opengis_netgml3_2_RingType_aggregationType', _module_typeBindings.AggregationType)
    __aggregationType._DeclarationLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 158, 2)
    __aggregationType._UseLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 158, 2)
    
    aggregationType = property(__aggregationType.value, __aggregationType.set, None, None)

    _ElementMap.update({
        __curveMember.name() : __curveMember
    })
    _AttributeMap.update({
        __aggregationType.name() : __aggregationType
    })
_module_typeBindings.RingType = RingType
_Namespace_gml.addCategoryObject('typeBinding', 'RingType', RingType)


# Complex type {http://www.opengis.net/gml/3.2}TinType with content type ELEMENT_ONLY
class TinType (SurfaceType):
    """Complex type {http://www.opengis.net/gml/3.2}TinType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'TinType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 735, 1)
    _ElementMap = SurfaceType._ElementMap.copy()
    _AttributeMap = SurfaceType._AttributeMap.copy()
    # Base type is SurfaceType
    
    # Element metaDataProperty ({http://www.opengis.net/gml/3.2}metaDataProperty) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element patches ({http://www.opengis.net/gml/3.2}patches) inherited from {http://www.opengis.net/gml/3.2}SurfaceType
    
    # Element {http://www.opengis.net/gml/3.2}stopLines uses Python identifier stopLines
    __stopLines = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'stopLines'), 'stopLines', '__httpwww_opengis_netgml3_2_TinType_httpwww_opengis_netgml3_2stopLines', True, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 739, 5), )

    
    stopLines = property(__stopLines.value, __stopLines.set, None, None)

    
    # Element {http://www.opengis.net/gml/3.2}breakLines uses Python identifier breakLines
    __breakLines = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'breakLines'), 'breakLines', '__httpwww_opengis_netgml3_2_TinType_httpwww_opengis_netgml3_2breakLines', True, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 740, 5), )

    
    breakLines = property(__breakLines.value, __breakLines.set, None, None)

    
    # Element {http://www.opengis.net/gml/3.2}maxLength uses Python identifier maxLength
    __maxLength = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'maxLength'), 'maxLength', '__httpwww_opengis_netgml3_2_TinType_httpwww_opengis_netgml3_2maxLength', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 741, 5), )

    
    maxLength = property(__maxLength.value, __maxLength.set, None, None)

    
    # Element {http://www.opengis.net/gml/3.2}controlPoint uses Python identifier controlPoint
    __controlPoint = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'controlPoint'), 'controlPoint', '__httpwww_opengis_netgml3_2_TinType_httpwww_opengis_netgml3_2controlPoint', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 742, 5), )

    
    controlPoint = property(__controlPoint.value, __controlPoint.set, None, None)

    
    # Element description ({http://www.opengis.net/gml/3.2}description) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element descriptionReference ({http://www.opengis.net/gml/3.2}descriptionReference) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element name ({http://www.opengis.net/gml/3.2}name) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element identifier ({http://www.opengis.net/gml/3.2}identifier) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Attribute srsName inherited from {http://www.opengis.net/gml/3.2}AbstractGeometryType
    
    # Attribute srsDimension inherited from {http://www.opengis.net/gml/3.2}AbstractGeometryType
    
    # Attribute axisLabels inherited from {http://www.opengis.net/gml/3.2}AbstractGeometryType
    
    # Attribute uomLabels inherited from {http://www.opengis.net/gml/3.2}AbstractGeometryType
    
    # Attribute id inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    _ElementMap.update({
        __stopLines.name() : __stopLines,
        __breakLines.name() : __breakLines,
        __maxLength.name() : __maxLength,
        __controlPoint.name() : __controlPoint
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.TinType = TinType
_Namespace_gml.addCategoryObject('typeBinding', 'TinType', TinType)


# Complex type {http://www.opengis.net/gml/3.2}ConversionType with content type ELEMENT_ONLY
class ConversionType (AbstractGeneralConversionType):
    """Complex type {http://www.opengis.net/gml/3.2}ConversionType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'ConversionType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 228, 1)
    _ElementMap = AbstractGeneralConversionType._ElementMap.copy()
    _AttributeMap = AbstractGeneralConversionType._AttributeMap.copy()
    # Base type is AbstractGeneralConversionType
    
    # Element coordinateOperationAccuracy ({http://www.opengis.net/gml/3.2}coordinateOperationAccuracy) inherited from {http://www.opengis.net/gml/3.2}AbstractCoordinateOperationType
    
    # Element {http://www.opengis.net/gml/3.2}method uses Python identifier method
    __method = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'method'), 'method', '__httpwww_opengis_netgml3_2_ConversionType_httpwww_opengis_netgml3_2method', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 238, 1), )

    
    method = property(__method.value, __method.set, None, 'gml:method is an association role to the operation method used by a coordinate operation.')

    
    # Element {http://www.opengis.net/gml/3.2}parameterValue uses Python identifier parameterValue
    __parameterValue = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'parameterValue'), 'parameterValue', '__httpwww_opengis_netgml3_2_ConversionType_httpwww_opengis_netgml3_2parameterValue', True, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 243, 1), )

    
    parameterValue = property(__parameterValue.value, __parameterValue.set, None, 'gml:parameterValue is a composition association to a parameter value or group of parameter values used by a coordinate operation.')

    
    # Element metaDataProperty ({http://www.opengis.net/gml/3.2}metaDataProperty) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element remarks ({http://www.opengis.net/gml/3.2}remarks) inherited from {http://www.opengis.net/gml/3.2}DefinitionType
    
    # Element description ({http://www.opengis.net/gml/3.2}description) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element descriptionReference ({http://www.opengis.net/gml/3.2}descriptionReference) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element name ({http://www.opengis.net/gml/3.2}name) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element identifier ({http://www.opengis.net/gml/3.2}identifier) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element domainOfValidity ({http://www.opengis.net/gml/3.2}domainOfValidity) inherited from {http://www.opengis.net/gml/3.2}AbstractCoordinateOperationType
    
    # Element scope ({http://www.opengis.net/gml/3.2}scope) inherited from {http://www.opengis.net/gml/3.2}AbstractCoordinateOperationType
    
    # Attribute id_2 inherited from {http://www.opengis.net/gml/3.2}AbstractGeneralConversionType
    _ElementMap.update({
        __method.name() : __method,
        __parameterValue.name() : __parameterValue
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.ConversionType = ConversionType
_Namespace_gml.addCategoryObject('typeBinding', 'ConversionType', ConversionType)


# Complex type {http://www.opengis.net/gml/3.2}TransformationType with content type ELEMENT_ONLY
class TransformationType (AbstractGeneralTransformationType):
    """Complex type {http://www.opengis.net/gml/3.2}TransformationType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'TransformationType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 264, 1)
    _ElementMap = AbstractGeneralTransformationType._ElementMap.copy()
    _AttributeMap = AbstractGeneralTransformationType._AttributeMap.copy()
    # Base type is AbstractGeneralTransformationType
    
    # Element operationVersion ({http://www.opengis.net/gml/3.2}operationVersion) inherited from {http://www.opengis.net/gml/3.2}AbstractCoordinateOperationType
    
    # Element coordinateOperationAccuracy ({http://www.opengis.net/gml/3.2}coordinateOperationAccuracy) inherited from {http://www.opengis.net/gml/3.2}AbstractCoordinateOperationType
    
    # Element sourceCRS ({http://www.opengis.net/gml/3.2}sourceCRS) inherited from {http://www.opengis.net/gml/3.2}AbstractCoordinateOperationType
    
    # Element targetCRS ({http://www.opengis.net/gml/3.2}targetCRS) inherited from {http://www.opengis.net/gml/3.2}AbstractCoordinateOperationType
    
    # Element {http://www.opengis.net/gml/3.2}method uses Python identifier method
    __method = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'method'), 'method', '__httpwww_opengis_netgml3_2_TransformationType_httpwww_opengis_netgml3_2method', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 238, 1), )

    
    method = property(__method.value, __method.set, None, 'gml:method is an association role to the operation method used by a coordinate operation.')

    
    # Element {http://www.opengis.net/gml/3.2}parameterValue uses Python identifier parameterValue
    __parameterValue = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'parameterValue'), 'parameterValue', '__httpwww_opengis_netgml3_2_TransformationType_httpwww_opengis_netgml3_2parameterValue', True, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 243, 1), )

    
    parameterValue = property(__parameterValue.value, __parameterValue.set, None, 'gml:parameterValue is a composition association to a parameter value or group of parameter values used by a coordinate operation.')

    
    # Element metaDataProperty ({http://www.opengis.net/gml/3.2}metaDataProperty) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element remarks ({http://www.opengis.net/gml/3.2}remarks) inherited from {http://www.opengis.net/gml/3.2}DefinitionType
    
    # Element description ({http://www.opengis.net/gml/3.2}description) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element descriptionReference ({http://www.opengis.net/gml/3.2}descriptionReference) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element name ({http://www.opengis.net/gml/3.2}name) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element identifier ({http://www.opengis.net/gml/3.2}identifier) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element domainOfValidity ({http://www.opengis.net/gml/3.2}domainOfValidity) inherited from {http://www.opengis.net/gml/3.2}AbstractCoordinateOperationType
    
    # Element scope ({http://www.opengis.net/gml/3.2}scope) inherited from {http://www.opengis.net/gml/3.2}AbstractCoordinateOperationType
    
    # Attribute id_2 inherited from {http://www.opengis.net/gml/3.2}AbstractGeneralTransformationType
    _ElementMap.update({
        __method.name() : __method,
        __parameterValue.name() : __parameterValue
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.TransformationType = TransformationType
_Namespace_gml.addCategoryObject('typeBinding', 'TransformationType', TransformationType)


# Complex type {http://www.opengis.net/gml/3.2}ProjectedCRSType with content type ELEMENT_ONLY
class ProjectedCRSType (AbstractGeneralDerivedCRSType):
    """Complex type {http://www.opengis.net/gml/3.2}ProjectedCRSType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'ProjectedCRSType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateReferenceSystems.xsd', 167, 1)
    _ElementMap = AbstractGeneralDerivedCRSType._ElementMap.copy()
    _AttributeMap = AbstractGeneralDerivedCRSType._AttributeMap.copy()
    # Base type is AbstractGeneralDerivedCRSType
    
    # Element conversion ({http://www.opengis.net/gml/3.2}conversion) inherited from {http://www.opengis.net/gml/3.2}AbstractGeneralDerivedCRSType
    
    # Element {http://www.opengis.net/gml/3.2}cartesianCS uses Python identifier cartesianCS
    __cartesianCS = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'cartesianCS'), 'cartesianCS', '__httpwww_opengis_netgml3_2_ProjectedCRSType_httpwww_opengis_netgml3_2cartesianCS', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateReferenceSystems.xsd', 103, 1), )

    
    cartesianCS = property(__cartesianCS.value, __cartesianCS.set, None, 'gml:cartesianCS is an association role to the Cartesian coordinate system used by this CRS.')

    
    # Element {http://www.opengis.net/gml/3.2}baseGeodeticCRS uses Python identifier baseGeodeticCRS
    __baseGeodeticCRS = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'baseGeodeticCRS'), 'baseGeodeticCRS', '__httpwww_opengis_netgml3_2_ProjectedCRSType_httpwww_opengis_netgml3_2baseGeodeticCRS', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateReferenceSystems.xsd', 180, 1), )

    
    baseGeodeticCRS = property(__baseGeodeticCRS.value, __baseGeodeticCRS.set, None, 'gml:baseGeodeticCRS is an association role to the geodetic coordinate reference system used by this projected CRS.')

    
    # Element {http://www.opengis.net/gml/3.2}baseGeographicCRS uses Python identifier baseGeographicCRS
    __baseGeographicCRS = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'baseGeographicCRS'), 'baseGeographicCRS', '__httpwww_opengis_netgml3_2_ProjectedCRSType_httpwww_opengis_netgml3_2baseGeographicCRS', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 381, 1), )

    
    baseGeographicCRS = property(__baseGeographicCRS.value, __baseGeographicCRS.set, None, '')

    
    # Element metaDataProperty ({http://www.opengis.net/gml/3.2}metaDataProperty) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element remarks ({http://www.opengis.net/gml/3.2}remarks) inherited from {http://www.opengis.net/gml/3.2}DefinitionType
    
    # Element description ({http://www.opengis.net/gml/3.2}description) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element descriptionReference ({http://www.opengis.net/gml/3.2}descriptionReference) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element name ({http://www.opengis.net/gml/3.2}name) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element identifier ({http://www.opengis.net/gml/3.2}identifier) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element domainOfValidity ({http://www.opengis.net/gml/3.2}domainOfValidity) inherited from {http://www.opengis.net/gml/3.2}AbstractCRSType
    
    # Element scope ({http://www.opengis.net/gml/3.2}scope) inherited from {http://www.opengis.net/gml/3.2}AbstractCRSType
    
    # Attribute id_ inherited from {http://www.opengis.net/gml/3.2}DefinitionBaseType
    _ElementMap.update({
        __cartesianCS.name() : __cartesianCS,
        __baseGeodeticCRS.name() : __baseGeodeticCRS,
        __baseGeographicCRS.name() : __baseGeographicCRS
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.ProjectedCRSType = ProjectedCRSType
_Namespace_gml.addCategoryObject('typeBinding', 'ProjectedCRSType', ProjectedCRSType)


# Complex type {http://www.opengis.net/gml/3.2}DerivedCRSType with content type ELEMENT_ONLY
class DerivedCRSType (AbstractGeneralDerivedCRSType):
    """Complex type {http://www.opengis.net/gml/3.2}DerivedCRSType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'DerivedCRSType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateReferenceSystems.xsd', 199, 1)
    _ElementMap = AbstractGeneralDerivedCRSType._ElementMap.copy()
    _AttributeMap = AbstractGeneralDerivedCRSType._AttributeMap.copy()
    # Base type is AbstractGeneralDerivedCRSType
    
    # Element conversion ({http://www.opengis.net/gml/3.2}conversion) inherited from {http://www.opengis.net/gml/3.2}AbstractGeneralDerivedCRSType
    
    # Element {http://www.opengis.net/gml/3.2}baseCRS uses Python identifier baseCRS
    __baseCRS = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'baseCRS'), 'baseCRS', '__httpwww_opengis_netgml3_2_DerivedCRSType_httpwww_opengis_netgml3_2baseCRS', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateReferenceSystems.xsd', 210, 1), )

    
    baseCRS = property(__baseCRS.value, __baseCRS.set, None, 'gml:baseCRS is an association role to the coordinate reference system used by this derived CRS.')

    
    # Element {http://www.opengis.net/gml/3.2}derivedCRSType uses Python identifier derivedCRSType
    __derivedCRSType = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'derivedCRSType'), 'derivedCRSType', '__httpwww_opengis_netgml3_2_DerivedCRSType_httpwww_opengis_netgml3_2derivedCRSType', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateReferenceSystems.xsd', 215, 1), )

    
    derivedCRSType = property(__derivedCRSType.value, __derivedCRSType.set, None, 'The gml:derivedCRSType property describes the type of a derived coordinate reference system. The required codeSpace attribute shall reference a source of information specifying the values and meanings of all the allowed string values for this property.')

    
    # Element {http://www.opengis.net/gml/3.2}coordinateSystem uses Python identifier coordinateSystem
    __coordinateSystem = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'coordinateSystem'), 'coordinateSystem', '__httpwww_opengis_netgml3_2_DerivedCRSType_httpwww_opengis_netgml3_2coordinateSystem', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateReferenceSystems.xsd', 220, 1), )

    
    coordinateSystem = property(__coordinateSystem.value, __coordinateSystem.set, None, 'An association role to the coordinate system used by this CRS.')

    
    # Element metaDataProperty ({http://www.opengis.net/gml/3.2}metaDataProperty) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element remarks ({http://www.opengis.net/gml/3.2}remarks) inherited from {http://www.opengis.net/gml/3.2}DefinitionType
    
    # Element description ({http://www.opengis.net/gml/3.2}description) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element descriptionReference ({http://www.opengis.net/gml/3.2}descriptionReference) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element name ({http://www.opengis.net/gml/3.2}name) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element identifier ({http://www.opengis.net/gml/3.2}identifier) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element domainOfValidity ({http://www.opengis.net/gml/3.2}domainOfValidity) inherited from {http://www.opengis.net/gml/3.2}AbstractCRSType
    
    # Element scope ({http://www.opengis.net/gml/3.2}scope) inherited from {http://www.opengis.net/gml/3.2}AbstractCRSType
    
    # Attribute id_ inherited from {http://www.opengis.net/gml/3.2}DefinitionBaseType
    _ElementMap.update({
        __baseCRS.name() : __baseCRS,
        __derivedCRSType.name() : __derivedCRSType,
        __coordinateSystem.name() : __coordinateSystem
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.DerivedCRSType = DerivedCRSType
_Namespace_gml.addCategoryObject('typeBinding', 'DerivedCRSType', DerivedCRSType)


# Complex type {http://www.opengis.net/gml/3.2}TemporalDatumType with content type ELEMENT_ONLY
class TemporalDatumType (TemporalDatumBaseType):
    """Complex type {http://www.opengis.net/gml/3.2}TemporalDatumType with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(_Namespace_gml, 'TemporalDatumType')
    _XSDLocation = pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/datums.xsd', 244, 1)
    _ElementMap = TemporalDatumBaseType._ElementMap.copy()
    _AttributeMap = TemporalDatumBaseType._AttributeMap.copy()
    # Base type is TemporalDatumBaseType
    
    # Element {http://www.opengis.net/gml/3.2}origin uses Python identifier origin
    __origin = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(_Namespace_gml, 'origin'), 'origin', '__httpwww_opengis_netgml3_2_TemporalDatumType_httpwww_opengis_netgml3_2origin', False, pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/datums.xsd', 273, 1), )

    
    origin = property(__origin.value, __origin.set, None, 'gml:origin is the date and time origin of this temporal datum.')

    
    # Element metaDataProperty ({http://www.opengis.net/gml/3.2}metaDataProperty) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element remarks ({http://www.opengis.net/gml/3.2}remarks) inherited from {http://www.opengis.net/gml/3.2}DefinitionType
    
    # Element description ({http://www.opengis.net/gml/3.2}description) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element descriptionReference ({http://www.opengis.net/gml/3.2}descriptionReference) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element name ({http://www.opengis.net/gml/3.2}name) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element identifier ({http://www.opengis.net/gml/3.2}identifier) inherited from {http://www.opengis.net/gml/3.2}AbstractGMLType
    
    # Element domainOfValidity ({http://www.opengis.net/gml/3.2}domainOfValidity) inherited from {http://www.opengis.net/gml/3.2}AbstractDatumType
    
    # Element scope ({http://www.opengis.net/gml/3.2}scope) inherited from {http://www.opengis.net/gml/3.2}AbstractDatumType
    
    # Attribute id_2 inherited from {http://www.opengis.net/gml/3.2}TemporalDatumBaseType
    _ElementMap.update({
        __origin.name() : __origin
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.TemporalDatumType = TemporalDatumType
_Namespace_gml.addCategoryObject('typeBinding', 'TemporalDatumType', TemporalDatumType)


CharacterString = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gco, 'CharacterString'), pyxb.binding.datatypes.string, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 163, 1))
_Namespace_gco.addCategoryObject('elementBinding', CharacterString.name().localName(), CharacterString)

Boolean = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gco, 'Boolean'), pyxb.binding.datatypes.boolean, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 173, 1))
_Namespace_gco.addCategoryObject('elementBinding', Boolean.name().localName(), Boolean)

DateTime = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gco, 'DateTime'), pyxb.binding.datatypes.dateTime, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 295, 1))
_Namespace_gco.addCategoryObject('elementBinding', DateTime.name().localName(), DateTime)

Decimal = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gco, 'Decimal'), pyxb.binding.datatypes.decimal, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 330, 1))
_Namespace_gco.addCategoryObject('elementBinding', Decimal.name().localName(), Decimal)

Real = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gco, 'Real'), pyxb.binding.datatypes.double, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 340, 1))
_Namespace_gco.addCategoryObject('elementBinding', Real.name().localName(), Real)

Integer = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gco, 'Integer'), pyxb.binding.datatypes.integer, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 350, 1))
_Namespace_gco.addCategoryObject('elementBinding', Integer.name().localName(), Integer)

Record = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gco, 'Record'), pyxb.binding.datatypes.anyType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 381, 1))
_Namespace_gco.addCategoryObject('elementBinding', Record.name().localName(), Record)

URL = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'URL'), pyxb.binding.datatypes.anyURI, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 227, 1))
_Namespace_gmd.addCategoryObject('elementBinding', URL.name().localName(), URL)

TM_PeriodDuration = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gts, 'TM_PeriodDuration'), pyxb.binding.datatypes.duration, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gts/temporalObjects.xsd', 26, 1))
_Namespace_gts.addCategoryObject('elementBinding', TM_PeriodDuration.name().localName(), TM_PeriodDuration)

operationVersion = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'operationVersion'), pyxb.binding.datatypes.string, documentation='gml:operationVersion is the version of the coordinate transformation (i.e., instantiation due to the stochastic nature of the parameters). Mandatory when describing a transformation, and should not be supplied for a conversion.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 43, 1))
_Namespace_gml.addCategoryObject('elementBinding', operationVersion.name().localName(), operationVersion)

modifiedCoordinate = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'modifiedCoordinate'), pyxb.binding.datatypes.positiveInteger, documentation='gml:modifiedCoordinate is a positive integer defining a position in a coordinate tuple.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 207, 1))
_Namespace_gml.addCategoryObject('elementBinding', modifiedCoordinate.name().localName(), modifiedCoordinate)

stringValue = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'stringValue'), pyxb.binding.datatypes.string, documentation='gml:stringValue is a character string value of an operation parameter. A string value does not have an associated unit of measure.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 329, 1))
_Namespace_gml.addCategoryObject('elementBinding', stringValue.name().localName(), stringValue)

integerValue = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'integerValue'), pyxb.binding.datatypes.positiveInteger, documentation='gml:integerValue is a positive integer value of an operation parameter, usually used for a count. An integer value does not have an associated unit of measure.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 334, 1))
_Namespace_gml.addCategoryObject('elementBinding', integerValue.name().localName(), integerValue)

booleanValue = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'booleanValue'), pyxb.binding.datatypes.boolean, documentation='gml:booleanValue is a boolean value of an operation parameter. A Boolean value does not have an associated unit of measure.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 339, 1))
_Namespace_gml.addCategoryObject('elementBinding', booleanValue.name().localName(), booleanValue)

valueFile = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'valueFile'), pyxb.binding.datatypes.anyURI, documentation='gml:valueFile is a reference to a file or a part of a file containing one or more parameter values, each numeric value with its associated unit of measure. When referencing a part of a file, that file shall contain multiple identified parts, such as an XML encoded document. Furthermore, the referenced file or part of a file may reference another part of the same or different files, as allowed in XML documents.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 354, 1))
_Namespace_gml.addCategoryObject('elementBinding', valueFile.name().localName(), valueFile)

sourceDimensions = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'sourceDimensions'), pyxb.binding.datatypes.positiveInteger, documentation='gml:sourceDimensions is the number of dimensions in the source CRS of this operation method.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 422, 1))
_Namespace_gml.addCategoryObject('elementBinding', sourceDimensions.name().localName(), sourceDimensions)

targetDimensions = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'targetDimensions'), pyxb.binding.datatypes.positiveInteger, documentation='gml:targetDimensions is the number of dimensions in the target CRS of this operation method.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 427, 1))
_Namespace_gml.addCategoryObject('elementBinding', targetDimensions.name().localName(), targetDimensions)

minimumOccurs = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'minimumOccurs'), pyxb.binding.datatypes.nonNegativeInteger, documentation='gml:minimumOccurs is the minimum number of times that values for this parameter group or parameter are required. If this attribute is omitted, the minimum number shall be one.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 460, 1))
_Namespace_gml.addCategoryObject('elementBinding', minimumOccurs.name().localName(), minimumOccurs)

maximumOccurs = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'maximumOccurs'), pyxb.binding.datatypes.positiveInteger, documentation='gml:maximumOccurs is the maximum number of times that values for this parameter group may be included. If this attribute is omitted, the maximum number shall be one.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 511, 1))
_Namespace_gml.addCategoryObject('elementBinding', maximumOccurs.name().localName(), maximumOccurs)

minimumValue = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'minimumValue'), pyxb.binding.datatypes.double, documentation='The gml:minimumValue and gml:maximumValue properties allow the specification of minimum and maximum value normally allowed for this axis, in the unit of measure for the axis. For a continuous angular axis such as longitude, the values wrap-around at this value. Also, values beyond this minimum/maximum can be used for specified purposes, such as in a bounding box. A value of minus infinity shall be allowed for the gml:minimumValue element, a value of plus infiniy for the gml:maximumValue element. If these elements are omitted, the value is unspecified.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateSystems.xsd', 54, 1))
_Namespace_gml.addCategoryObject('elementBinding', minimumValue.name().localName(), minimumValue)

maximumValue = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'maximumValue'), pyxb.binding.datatypes.double, documentation='The gml:minimumValue and gml:maximumValue properties allow the specification of minimum and maximum value normally allowed for this axis, in the unit of measure for the axis. For a continuous angular axis such as longitude, the values wrap-around at this value. Also, values beyond this minimum/maximum can be used for specified purposes, such as in a bounding box. A value of minus infinity shall be allowed for the gml:minimumValue element, a value of plus infiniy for the gml:maximumValue element. If these elements are omitted, the value is unspecified.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateSystems.xsd', 59, 1))
_Namespace_gml.addCategoryObject('elementBinding', maximumValue.name().localName(), maximumValue)

realizationEpoch = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'realizationEpoch'), pyxb.binding.datatypes.date, documentation='gml:realizationEpoch is the time after which this datum definition is valid. See ISO 19111 Table 32 for details.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/datums.xsd', 47, 1))
_Namespace_gml.addCategoryObject('elementBinding', realizationEpoch.name().localName(), realizationEpoch)

origin = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'origin'), pyxb.binding.datatypes.dateTime, documentation='gml:origin is the date and time origin of this temporal datum.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/datums.xsd', 273, 1))
_Namespace_gml.addCategoryObject('elementBinding', origin.name().localName(), origin)

remarks = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'remarks'), pyxb.binding.datatypes.string, location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 54, 1))
_Namespace_gml.addCategoryObject('elementBinding', remarks.name().localName(), remarks)

AbstractObject = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractObject'), pyxb.binding.datatypes.anyType, abstract=pyxb.binding.datatypes.boolean(1), documentation='This element has no type defined, and is therefore implicitly (according to the rules of W3C XML Schema) an XML Schema anyType. It is used as the head of an XML Schema substitution group which unifies complex content and certain simple content elements used for datatypes in GML, including the gml:AbstractGML substitution group.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 21, 1))
_Namespace_gml.addCategoryObject('elementBinding', AbstractObject.name().localName(), AbstractObject)

reversePropertyName = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'reversePropertyName'), pyxb.binding.datatypes.string, documentation='If the value of an object property is another object and that object contains also a property for the association between the two objects, then this name of the reverse property may be encoded in a gml:reversePropertyName element in an appinfo annotation of the property element to document the constraint between the two properties. The value of the element shall contain the qualified name of the property element.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 112, 1))
_Namespace_gml.addCategoryObject('elementBinding', reversePropertyName.name().localName(), reversePropertyName)

targetElement = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'targetElement'), pyxb.binding.datatypes.string, location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 181, 1))
_Namespace_gml.addCategoryObject('elementBinding', targetElement.name().localName(), targetElement)

associationName = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'associationName'), pyxb.binding.datatypes.string, location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 182, 1))
_Namespace_gml.addCategoryObject('elementBinding', associationName.name().localName(), associationName)

defaultCodeSpace = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'defaultCodeSpace'), pyxb.binding.datatypes.anyURI, location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 183, 1))
_Namespace_gml.addCategoryObject('elementBinding', defaultCodeSpace.name().localName(), defaultCodeSpace)

gmlProfileSchema = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'gmlProfileSchema'), pyxb.binding.datatypes.anyURI, location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 184, 1))
_Namespace_gml.addCategoryObject('elementBinding', gmlProfileSchema.name().localName(), gmlProfileSchema)

scope = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'scope'), pyxb.binding.datatypes.string, documentation='The gml:scope property provides a description of the usage, or limitations of usage, for which this CRS-related object is valid. If unknown, enter "not known".', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/referenceSystems.xsd', 56, 1))
_Namespace_gml.addCategoryObject('elementBinding', scope.name().localName(), scope)

duration = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'duration'), pyxb.binding.datatypes.duration, documentation='gml:duration conforms to the ISO 8601 syntax for temporal length as implemented by the XML Schema duration type.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporal.xsd', 229, 1))
_Namespace_gml.addCategoryObject('elementBinding', duration.name().localName(), duration)

AbstractValue = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractValue'), pyxb.binding.datatypes.anyType, abstract=pyxb.binding.datatypes.boolean(1), documentation='gml:AbstractValue is an abstract element which acts as the head of a substitution group which contains gml:AbstractScalarValue, gml:AbstractScalarValueList, gml:CompositeValue and gml:ValueExtent, and (transitively) the elements in their substitution groups.\nThese elements may be used in an application schema as variables, so that in an XML instance document any member of its substitution group may occur.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/valueObjects.xsd', 70, 1))
_Namespace_gml.addCategoryObject('elementBinding', AbstractValue.name().localName(), AbstractValue)

AbstractScalarValue = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractScalarValue'), pyxb.binding.datatypes.anyType, abstract=pyxb.binding.datatypes.boolean(1), documentation='gml:AbstractScalarValue is an abstract element which acts as the head of a substitution group which contains gml:Boolean, gml:Category, gml:Count and gml:Quantity, and (transitively) the elements in their substitution groups.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/valueObjects.xsd', 76, 1))
_Namespace_gml.addCategoryObject('elementBinding', AbstractScalarValue.name().localName(), AbstractScalarValue)

AbstractScalarValueList = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractScalarValueList'), pyxb.binding.datatypes.anyType, abstract=pyxb.binding.datatypes.boolean(1), documentation='gml:AbstractScalarValueList is an abstract element which acts as the head of a substitution group which contains gml:BooleanList, gml:CategoryList, gml:CountList and gml:QuantityList, and (transitively) the elements in their substitution groups.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/valueObjects.xsd', 81, 1))
_Namespace_gml.addCategoryObject('elementBinding', AbstractScalarValueList.name().localName(), AbstractScalarValueList)

AbstractGenericName = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gco, 'AbstractGenericName'), CodeType, abstract=pyxb.binding.datatypes.boolean(1), location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 183, 1))
_Namespace_gco.addCategoryObject('elementBinding', AbstractGenericName.name().localName(), AbstractGenericName)

LocalName = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gco, 'LocalName'), CodeType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 193, 1))
_Namespace_gco.addCategoryObject('elementBinding', LocalName.name().localName(), LocalName)

ScopedName = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gco, 'ScopedName'), CodeType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 203, 1))
_Namespace_gco.addCategoryObject('elementBinding', ScopedName.name().localName(), ScopedName)

Date = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gco, 'Date'), Date_Type, nillable=pyxb.binding.datatypes.boolean(1), location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 308, 1))
_Namespace_gco.addCategoryObject('elementBinding', Date.name().localName(), Date)

UnlimitedInteger = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gco, 'UnlimitedInteger'), UnlimitedInteger_Type, nillable=pyxb.binding.datatypes.boolean(1), location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 370, 1))
_Namespace_gco.addCategoryObject('elementBinding', UnlimitedInteger.name().localName(), UnlimitedInteger)

Binary = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gco, 'Binary'), Binary_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 420, 1))
_Namespace_gco.addCategoryObject('elementBinding', Binary.name().localName(), Binary)

AbstractObject_ = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gco, 'AbstractObject'), AbstractObject_Type, abstract=pyxb.binding.datatypes.boolean(1), location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/gcoBase.xsd', 24, 1))
_Namespace_gco.addCategoryObject('elementBinding', AbstractObject_.name().localName(), AbstractObject_)

CI_RoleCode = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'CI_RoleCode'), CodeListValue_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 237, 1))
_Namespace_gmd.addCategoryObject('elementBinding', CI_RoleCode.name().localName(), CI_RoleCode)

CI_PresentationFormCode = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'CI_PresentationFormCode'), CodeListValue_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 247, 1))
_Namespace_gmd.addCategoryObject('elementBinding', CI_PresentationFormCode.name().localName(), CI_PresentationFormCode)

CI_OnLineFunctionCode = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'CI_OnLineFunctionCode'), CodeListValue_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 257, 1))
_Namespace_gmd.addCategoryObject('elementBinding', CI_OnLineFunctionCode.name().localName(), CI_OnLineFunctionCode)

CI_DateTypeCode = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'CI_DateTypeCode'), CodeListValue_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 267, 1))
_Namespace_gmd.addCategoryObject('elementBinding', CI_DateTypeCode.name().localName(), CI_DateTypeCode)

MD_ClassificationCode = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_ClassificationCode'), CodeListValue_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/constraints.xsd', 88, 1))
_Namespace_gmd.addCategoryObject('elementBinding', MD_ClassificationCode.name().localName(), MD_ClassificationCode)

MD_RestrictionCode = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_RestrictionCode'), CodeListValue_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/constraints.xsd', 98, 1))
_Namespace_gmd.addCategoryObject('elementBinding', MD_RestrictionCode.name().localName(), MD_RestrictionCode)

MD_CoverageContentTypeCode = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_CoverageContentTypeCode'), CodeListValue_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/content.xsd', 171, 1))
_Namespace_gmd.addCategoryObject('elementBinding', MD_CoverageContentTypeCode.name().localName(), MD_CoverageContentTypeCode)

MD_ImagingConditionCode = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_ImagingConditionCode'), CodeListValue_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/content.xsd', 181, 1))
_Namespace_gmd.addCategoryObject('elementBinding', MD_ImagingConditionCode.name().localName(), MD_ImagingConditionCode)

DQ_EvaluationMethodTypeCode = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'DQ_EvaluationMethodTypeCode'), CodeListValue_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 547, 1))
_Namespace_gmd.addCategoryObject('elementBinding', DQ_EvaluationMethodTypeCode.name().localName(), DQ_EvaluationMethodTypeCode)

MD_DistributionUnits = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_DistributionUnits'), CodeListValue_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/distribution.xsd', 174, 1))
_Namespace_gmd.addCategoryObject('elementBinding', MD_DistributionUnits.name().localName(), MD_DistributionUnits)

MD_MediumFormatCode = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_MediumFormatCode'), CodeListValue_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/distribution.xsd', 184, 1))
_Namespace_gmd.addCategoryObject('elementBinding', MD_MediumFormatCode.name().localName(), MD_MediumFormatCode)

MD_MediumNameCode = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_MediumNameCode'), CodeListValue_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/distribution.xsd', 194, 1))
_Namespace_gmd.addCategoryObject('elementBinding', MD_MediumNameCode.name().localName(), MD_MediumNameCode)

LocalisedCharacterString = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'LocalisedCharacterString'), LocalisedCharacterString_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/freeText.xsd', 67, 1))
_Namespace_gmd.addCategoryObject('elementBinding', LocalisedCharacterString.name().localName(), LocalisedCharacterString)

PT_LocaleContainer = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'PT_LocaleContainer'), PT_LocaleContainer_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/freeText.xsd', 89, 1))
_Namespace_gmd.addCategoryObject('elementBinding', PT_LocaleContainer.name().localName(), PT_LocaleContainer)

LanguageCode = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'LanguageCode'), CodeListValue_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/freeText.xsd', 103, 1))
_Namespace_gmd.addCategoryObject('elementBinding', LanguageCode.name().localName(), LanguageCode)

Country = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'Country'), CodeListValue_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/freeText.xsd', 113, 1))
_Namespace_gmd.addCategoryObject('elementBinding', Country.name().localName(), Country)

MD_Resolution = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_Resolution'), MD_Resolution_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 244, 1))
_Namespace_gmd.addCategoryObject('elementBinding', MD_Resolution.name().localName(), MD_Resolution)

MD_TopicCategoryCode = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_TopicCategoryCode'), MD_TopicCategoryCode_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 280, 1))
_Namespace_gmd.addCategoryObject('elementBinding', MD_TopicCategoryCode.name().localName(), MD_TopicCategoryCode)

MD_CharacterSetCode = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_CharacterSetCode'), CodeListValue_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 290, 1))
_Namespace_gmd.addCategoryObject('elementBinding', MD_CharacterSetCode.name().localName(), MD_CharacterSetCode)

MD_SpatialRepresentationTypeCode = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_SpatialRepresentationTypeCode'), CodeListValue_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 300, 1))
_Namespace_gmd.addCategoryObject('elementBinding', MD_SpatialRepresentationTypeCode.name().localName(), MD_SpatialRepresentationTypeCode)

MD_ProgressCode = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_ProgressCode'), CodeListValue_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 310, 1))
_Namespace_gmd.addCategoryObject('elementBinding', MD_ProgressCode.name().localName(), MD_ProgressCode)

MD_KeywordTypeCode = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_KeywordTypeCode'), CodeListValue_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 320, 1))
_Namespace_gmd.addCategoryObject('elementBinding', MD_KeywordTypeCode.name().localName(), MD_KeywordTypeCode)

DS_AssociationTypeCode = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'DS_AssociationTypeCode'), CodeListValue_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 330, 1))
_Namespace_gmd.addCategoryObject('elementBinding', DS_AssociationTypeCode.name().localName(), DS_AssociationTypeCode)

DS_InitiativeTypeCode = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'DS_InitiativeTypeCode'), CodeListValue_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 340, 1))
_Namespace_gmd.addCategoryObject('elementBinding', DS_InitiativeTypeCode.name().localName(), DS_InitiativeTypeCode)

MD_ScopeDescription = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_ScopeDescription'), MD_ScopeDescription_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/maintenance.xsd', 58, 1))
_Namespace_gmd.addCategoryObject('elementBinding', MD_ScopeDescription.name().localName(), MD_ScopeDescription)

MD_MaintenanceFrequencyCode = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_MaintenanceFrequencyCode'), CodeListValue_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/maintenance.xsd', 68, 1))
_Namespace_gmd.addCategoryObject('elementBinding', MD_MaintenanceFrequencyCode.name().localName(), MD_MaintenanceFrequencyCode)

MD_ScopeCode = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_ScopeCode'), CodeListValue_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/maintenance.xsd', 78, 1))
_Namespace_gmd.addCategoryObject('elementBinding', MD_ScopeCode.name().localName(), MD_ScopeCode)

MD_ObligationCode = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_ObligationCode'), MD_ObligationCode_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataExtension.xsd', 81, 1))
_Namespace_gmd.addCategoryObject('elementBinding', MD_ObligationCode.name().localName(), MD_ObligationCode)

MD_DatatypeCode = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_DatatypeCode'), CodeListValue_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataExtension.xsd', 91, 1))
_Namespace_gmd.addCategoryObject('elementBinding', MD_DatatypeCode.name().localName(), MD_DatatypeCode)

MD_PixelOrientationCode = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_PixelOrientationCode'), MD_PixelOrientationCode_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/spatialRepresentation.xsd', 189, 1))
_Namespace_gmd.addCategoryObject('elementBinding', MD_PixelOrientationCode.name().localName(), MD_PixelOrientationCode)

MD_TopologyLevelCode = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_TopologyLevelCode'), CodeListValue_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/spatialRepresentation.xsd', 199, 1))
_Namespace_gmd.addCategoryObject('elementBinding', MD_TopologyLevelCode.name().localName(), MD_TopologyLevelCode)

MD_GeometricObjectTypeCode = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_GeometricObjectTypeCode'), CodeListValue_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/spatialRepresentation.xsd', 209, 1))
_Namespace_gmd.addCategoryObject('elementBinding', MD_GeometricObjectTypeCode.name().localName(), MD_GeometricObjectTypeCode)

MD_CellGeometryCode = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_CellGeometryCode'), CodeListValue_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/spatialRepresentation.xsd', 219, 1))
_Namespace_gmd.addCategoryObject('elementBinding', MD_CellGeometryCode.name().localName(), MD_CellGeometryCode)

MD_DimensionNameTypeCode = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_DimensionNameTypeCode'), CodeListValue_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/spatialRepresentation.xsd', 229, 1))
_Namespace_gmd.addCategoryObject('elementBinding', MD_DimensionNameTypeCode.name().localName(), MD_DimensionNameTypeCode)

parameterValue = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'parameterValue'), AbstractGeneralParameterValuePropertyType, documentation='gml:parameterValue is a composition association to a parameter value or group of parameter values used by a coordinate operation.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 243, 1))
_Namespace_gml.addCategoryObject('elementBinding', parameterValue.name().localName(), parameterValue)

AbstractGeneralParameterValue = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractGeneralParameterValue'), AbstractGeneralParameterValueType, abstract=pyxb.binding.datatypes.boolean(1), documentation='gml:AbstractGeneralParameterValue is an abstract parameter value or group of parameter values.\nThis abstract complexType is expected to be extended and restricted for well-known operation methods with many instances, in Application Schemas that define operation-method-specialized element names and contents. Specific parameter value elements are directly contained in concrete subtypes, not in this abstract type. All concrete types derived from this type shall extend this type to include one "...Value" element with an appropriate type, which should be one of the element types allowed in the ParameterValueType. In addition, all derived concrete types shall extend this type to include a "operationParameter" property element that references one element substitutable for the "OperationParameter" object element.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 283, 1))
_Namespace_gml.addCategoryObject('elementBinding', AbstractGeneralParameterValue.name().localName(), AbstractGeneralParameterValue)

integerValueList = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'integerValueList'), integerList, documentation='gml:integerValueList is an ordered sequence of two or more integer values of an operation parameter list, usually used for counts. These integer values do not have an associated unit of measure. An element of this type contains a space-separated sequence of integer values.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 349, 1))
_Namespace_gml.addCategoryObject('elementBinding', integerValueList.name().localName(), integerValueList)

formula = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'formula'), CodeType, documentation='gml:formula Formula(s) or procedure used by an operation method. The use of the codespace attribite has been deprecated. The property value shall be a character string.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 417, 1))
_Namespace_gml.addCategoryObject('elementBinding', formula.name().localName(), formula)

axisAbbrev = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'axisAbbrev'), CodeType, documentation='gml:axisAbbrev is the abbreviation used for this coordinate system axis; this abbreviation is also used to identify the coordinates in the coordinate tuple. The codeSpace attribute may reference a source of more information on a set of standardized abbreviations, or on this abbreviation.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateSystems.xsd', 42, 1))
_Namespace_gml.addCategoryObject('elementBinding', axisAbbrev.name().localName(), axisAbbrev)

rangeSet = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'rangeSet'), RangeSetType, documentation='The gml:rangeSet property element contains the values of the coverage (sometimes called the attribute values).  Its content model is given by gml:RangeSetType.\nThis content model supports a structural description of the range.  The semantic information describing the range set is embedded using a uniform method, as part of the explicit values, or as a template value accompanying the representation using gml:DataBlock and gml:File.\nThe values from each component (or "band") in the range may be encoded within a gml:ValueArray element or a concrete member of the gml:AbstractScalarValueList substitution group . Use of these elements satisfies the value-type homogeneity requirement.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coverage.xsd', 88, 1))
_Namespace_gml.addCategoryObject('elementBinding', rangeSet.name().localName(), rangeSet)

DataBlock = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'DataBlock'), DataBlockType, documentation='gml:DataBlock describes the Range as a block of text encoded values similar to a Common Separated Value (CSV) representation.\nThe range set parameterization is described by the property gml:rangeParameters.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coverage.xsd', 103, 1))
_Namespace_gml.addCategoryObject('elementBinding', DataBlock.name().localName(), DataBlock)

tupleList = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'tupleList'), CoordinatesType, documentation='gml:CoordinatesType consists of a list of coordinate tuples, with each coordinate tuple separated by the ts or tuple separator (whitespace), and each coordinate in the tuple by the cs or coordinate separator (comma).\nThe gml:tupleList encoding is effectively "band-interleaved".', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coverage.xsd', 119, 1))
_Namespace_gml.addCategoryObject('elementBinding', tupleList.name().localName(), tupleList)

File = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'File'), FileType, documentation='for efficiency reasons, GML also provides a means of encoding the range set in an arbitrary external encoding, such as a binary file.  This encoding may be "well-known" but this is not required. This mode uses the gml:File element.\nThe values of the coverage (attribute values in the range set) are transmitted in a external file that is referenced from the XML structure described by gml:FileType.  The external file is referenced by the gml:fileReference property that is an anyURI (the gml:fileName property has been deprecated).  This means that the external file may be located remotely from the referencing GML instance. \nThe gml:compression property points to a definition of a compression algorithm through an anyURI.  This may be a retrievable, computable definition or simply a reference to an unambiguous name for the compression method.\nThe gml:mimeType property points to a definition of the file mime type.\nThe gml:fileStructure property is defined by a codelist. Note further that all values shall be enclosed in a single file. Multi-file structures for values are not supported in GML.\nThe semantics of the range set is described as above using the gml:rangeParameters property.\nNote that if any compression algorithm is applied, the structure above applies only to the pre-compression or post-decompression structure of the file.\nNote that the fields within a record match the gml:valueComponents of the gml:CompositeValue in document order.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coverage.xsd', 130, 1))
_Namespace_gml.addCategoryObject('elementBinding', File.name().localName(), File)

coverageFunction = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'coverageFunction'), CoverageFunctionType, documentation='The gml:coverageFunction property describes the mapping function from the domain to the range of the coverage.\nThe value of the CoverageFunction is one of gml:CoverageMappingRule and gml:GridFunction.\nIf the gml:coverageFunction property is omitted for a gridded coverage (including rectified gridded coverages) the gml:startPoint is assumed to be the value of the gml:low property in the gml:Grid geometry, and the gml:sequenceRule is assumed to be linear and the gml:axisOrder property is assumed to be "+1 +2".', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coverage.xsd', 158, 1))
_Namespace_gml.addCategoryObject('elementBinding', coverageFunction.name().localName(), coverageFunction)

CoverageMappingRule = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'CoverageMappingRule'), MappingRuleType, documentation="gml:CoverageMappingRule provides a formal or informal description of the coverage function.\nThe mapping rule may be defined as an in-line string (gml:ruleDefinition) or via a remote reference through xlink:href (gml:ruleReference).  \nIf no rule name is specified, the default is 'Linear' with respect to members of the domain in document order.", location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coverage.xsd', 172, 1))
_Namespace_gml.addCategoryObject('elementBinding', CoverageMappingRule.name().localName(), CoverageMappingRule)

GridFunction = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'GridFunction'), GridFunctionType, documentation='gml:GridFunction provides an explicit mapping rule for grid geometries, i.e. the domain shall be a geometry of type grid.  It describes the mapping of grid posts (discrete point grid coverage) or grid cells (discrete surface coverage) to the values in the range set.\nThe gml:startPoint is the index position of a point in the grid that is mapped to the first point in the range set (this is also the index position of the first grid post).  If the gml:startPoint property is omitted the gml:startPoint is assumed to be equal to the value of gml:low in the gml:Grid geometry. Subsequent points in the mapping are determined by the value of the gml:sequenceRule.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coverage.xsd', 185, 1))
_Namespace_gml.addCategoryObject('elementBinding', GridFunction.name().localName(), GridFunction)

anchorDefinition = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'anchorDefinition'), CodeType, documentation='gml:anchorDefinition is a description, possibly including coordinates, of the definition used to anchor the datum to the Earth. Also known as the "origin", especially for engineering and image datums. The codeSpace attribute may be used to reference a source of more detailed on this point or surface, or on a set of such descriptions.\n-\tFor a geodetic datum, this point is also known as the fundamental point, which is traditionally the point where the relationship between geoid and ellipsoid is defined. In some cases, the "fundamental point" may consist of a number of points. In those cases, the parameters defining the geoid/ellipsoid relationship have been averaged for these points, and the averages adopted as the datum definition.\n-\tFor an engineering datum, the anchor definition may be a physical point, or it may be a point with defined coordinates in another CRS.may\n-\tFor an image datum, the anchor definition is usually either the centre of the image or the corner of the image.\n-\tFor a temporal datum, this attribute is not defined. Instead of the anchor definition, a temporal datum carries a separate time origin of type DateTime.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/datums.xsd', 38, 1))
_Namespace_gml.addCategoryObject('elementBinding', anchorDefinition.name().localName(), anchorDefinition)

secondDefiningParameter = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'secondDefiningParameter'), CTD_ANON, documentation='gml:secondDefiningParameter is a property containing the definition of the second parameter that defines the shape of an ellipsoid. An ellipsoid requires two defining parameters: semi-major axis and inverse flattening or semi-major axis and semi-minor axis. When the reference body is a sphere rather than an ellipsoid, only a single defining parameter is required, namely the radius of the sphere; in that case, the semi-major axis "degenerates" into the radius of the sphere.\nThe inverseFlattening element contains the inverse flattening value of the ellipsoid. This value is a scale factor (or ratio). It uses gml:LengthType with the restriction that the unit of measure referenced by the uom attribute must be suitable for a scale factor, such as percent, permil, or parts-per-million.\nThe semiMinorAxis element contains the length of the semi-minor axis of the ellipsoid. When the isSphere element is included, the ellipsoid is degenerate and is actually a sphere. The sphere is completely defined by the semi-major axis, which is the radius of the sphere.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/datums.xsd', 115, 1))
_Namespace_gml.addCategoryObject('elementBinding', secondDefiningParameter.name().localName(), secondDefiningParameter)

SecondDefiningParameter = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'SecondDefiningParameter'), CTD_ANON_, location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/datums.xsd', 127, 1))
_Namespace_gml.addCategoryObject('elementBinding', SecondDefiningParameter.name().localName(), SecondDefiningParameter)

anchorPoint = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'anchorPoint'), CodeType, documentation='', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 18, 1))
_Namespace_gml.addCategoryObject('elementBinding', anchorPoint.name().localName(), anchorPoint)

usesValue = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'usesValue'), AbstractGeneralParameterValuePropertyType, documentation='', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 137, 1))
_Namespace_gml.addCategoryObject('elementBinding', usesValue.name().localName(), usesValue)

dmsAngleValue = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'dmsAngleValue'), DMSAngleType, documentation='', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 152, 1))
_Namespace_gml.addCategoryObject('elementBinding', dmsAngleValue.name().localName(), dmsAngleValue)

includesValue = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'includesValue'), AbstractGeneralParameterValuePropertyType, documentation='', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 162, 1))
_Namespace_gml.addCategoryObject('elementBinding', includesValue.name().localName(), includesValue)

methodFormula = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'methodFormula'), CodeType, documentation='', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 172, 1))
_Namespace_gml.addCategoryObject('elementBinding', methodFormula.name().localName(), methodFormula)

dmsAngle = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'dmsAngle'), DMSAngleType, documentation='', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 534, 1))
_Namespace_gml.addCategoryObject('elementBinding', dmsAngle.name().localName(), dmsAngle)

decimalMinutes = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'decimalMinutes'), DecimalMinutesType, documentation='', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 588, 1))
_Namespace_gml.addCategoryObject('elementBinding', decimalMinutes.name().localName(), decimalMinutes)

minutes = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'minutes'), ArcMinutesType, documentation='', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 602, 1))
_Namespace_gml.addCategoryObject('elementBinding', minutes.name().localName(), minutes)

seconds = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'seconds'), ArcSecondsType, documentation='', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 615, 1))
_Namespace_gml.addCategoryObject('elementBinding', seconds.name().localName(), seconds)

members = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'members'), ArrayAssociationType, documentation='', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 657, 1))
_Namespace_gml.addCategoryObject('elementBinding', members.name().localName(), members)

AbstractMetaData = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractMetaData'), AbstractMetaDataType, abstract=pyxb.binding.datatypes.boolean(1), documentation='', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 722, 1))
_Namespace_gml.addCategoryObject('elementBinding', AbstractMetaData.name().localName(), AbstractMetaData)

coordinates = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'coordinates'), CoordinatesType, documentation='', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 751, 1))
_Namespace_gml.addCategoryObject('elementBinding', coordinates.name().localName(), coordinates)

LocationKeyWord = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'LocationKeyWord'), CodeType, documentation='', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 785, 1))
_Namespace_gml.addCategoryObject('elementBinding', LocationKeyWord.name().localName(), LocationKeyWord)

featureMembers = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'featureMembers'), FeatureArrayPropertyType, documentation='', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 823, 1))
_Namespace_gml.addCategoryObject('elementBinding', featureMembers.name().localName(), featureMembers)

track = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'track'), HistoryPropertyType, documentation='', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 873, 1))
_Namespace_gml.addCategoryObject('elementBinding', track.name().localName(), track)

indirectEntry = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'indirectEntry'), IndirectEntryType, documentation='', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 888, 1))
_Namespace_gml.addCategoryObject('elementBinding', indirectEntry.name().localName(), indirectEntry)

polygonPatches = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'polygonPatches'), SurfacePatchArrayPropertyType, documentation='', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 999, 1))
_Namespace_gml.addCategoryObject('elementBinding', polygonPatches.name().localName(), polygonPatches)

trianglePatches = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'trianglePatches'), SurfacePatchArrayPropertyType, documentation='', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 1004, 1))
_Namespace_gml.addCategoryObject('elementBinding', trianglePatches.name().localName(), trianglePatches)

pointArrayProperty = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'pointArrayProperty'), PointArrayPropertyType, documentation='', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 1113, 1))
_Namespace_gml.addCategoryObject('elementBinding', pointArrayProperty.name().localName(), pointArrayProperty)

curveArrayProperty = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'curveArrayProperty'), CurveArrayPropertyType, documentation='', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 1118, 1))
_Namespace_gml.addCategoryObject('elementBinding', curveArrayProperty.name().localName(), curveArrayProperty)

surfaceArrayProperty = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'surfaceArrayProperty'), SurfaceArrayPropertyType, documentation='', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 1123, 1))
_Namespace_gml.addCategoryObject('elementBinding', surfaceArrayProperty.name().localName(), surfaceArrayProperty)

solidArrayProperty = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'solidArrayProperty'), SolidArrayPropertyType, documentation='', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 1128, 1))
_Namespace_gml.addCategoryObject('elementBinding', solidArrayProperty.name().localName(), solidArrayProperty)

history = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'history'), HistoryPropertyType, documentation='A generic sequence of events constitute a gml:history of an object.\nThe gml:history element contains a set of elements in the substitution group headed by the abstract element gml:AbstractTimeSlice, representing the time-varying properties of interest. The history property of a dynamic feature associates a feature instance with a sequence of time slices (i.e. change events) that encapsulate the evolution of the feature.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dynamicFeature.xsd', 97, 1))
_Namespace_gml.addCategoryObject('elementBinding', history.name().localName(), history)

locationName = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'locationName'), CodeType, documentation='The gml:locationName property element is a convenience property where the text value describes the location of the feature. If the location names are selected from a controlled list, then the list shall be identified in the codeSpace attribute.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/feature.xsd', 76, 1))
_Namespace_gml.addCategoryObject('elementBinding', locationName.name().localName(), locationName)

geometryMembers = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'geometryMembers'), GeometryArrayPropertyType, documentation='This property element contains a list of geometry elements. The order of the elements is significant and shall be preserved when processing the array.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryAggregates.xsd', 48, 1))
_Namespace_gml.addCategoryObject('elementBinding', geometryMembers.name().localName(), geometryMembers)

pointMembers = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'pointMembers'), PointArrayPropertyType, documentation='This property element contains a list of points. The order of the elements is significant and shall be preserved when processing the array.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryAggregates.xsd', 84, 1))
_Namespace_gml.addCategoryObject('elementBinding', pointMembers.name().localName(), pointMembers)

curveMembers = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'curveMembers'), CurveArrayPropertyType, documentation='This property element contains a list of curves. The order of the elements is significant and shall be preserved when processing the array.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryAggregates.xsd', 115, 1))
_Namespace_gml.addCategoryObject('elementBinding', curveMembers.name().localName(), curveMembers)

surfaceMembers = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'surfaceMembers'), SurfaceArrayPropertyType, documentation='This property element contains a list of surfaces. The order of the elements is significant and shall be preserved when processing the array.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryAggregates.xsd', 146, 1))
_Namespace_gml.addCategoryObject('elementBinding', surfaceMembers.name().localName(), surfaceMembers)

solidMembers = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'solidMembers'), SolidArrayPropertyType, documentation='This property element contains a list of solids. The order of the elements is significant and shall be preserved when processing the array.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryAggregates.xsd', 182, 1))
_Namespace_gml.addCategoryObject('elementBinding', solidMembers.name().localName(), solidMembers)

exterior = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'exterior'), AbstractRingPropertyType, documentation='A boundary of a surface consists of a number of rings. In the normal 2D case, one of these rings is distinguished as being the exterior boundary. In a general manifold this is not always possible, in which case all boundaries shall be listed as interior boundaries, and the exterior will be empty.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic2d.xsd', 67, 1))
_Namespace_gml.addCategoryObject('elementBinding', exterior.name().localName(), exterior)

interior = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'interior'), AbstractRingPropertyType, documentation='A boundary of a surface consists of a number of rings. The "interior" rings separate the surface / surface patch from the area enclosed by the rings.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic2d.xsd', 72, 1))
_Namespace_gml.addCategoryObject('elementBinding', interior.name().localName(), interior)

AbstractCurveSegment = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractCurveSegment'), AbstractCurveSegmentType, abstract=pyxb.binding.datatypes.boolean(1), documentation='A curve segment defines a homogeneous segment of a curve.\nThe attributes numDerivativesAtStart, numDerivativesAtEnd and numDerivativesInterior specify the type of continuity as specified in ISO 19107:2003, 6.4.9.3.\nThe AbstractCurveSegment element is the abstract head of the substituition group for all curve segment elements, i.e. continuous segments of the same interpolation mechanism.\nAll curve segments shall have an attribute interpolation with type gml:CurveInterpolationType specifying the curve interpolation mechanism used for this segment. This mechanism uses the control points and control parameters to determine the position of this curve segment.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 57, 1))
_Namespace_gml.addCategoryObject('elementBinding', AbstractCurveSegment.name().localName(), AbstractCurveSegment)

segments = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'segments'), CurveSegmentArrayPropertyType, documentation='This property element contains a list of curve segments. The order of the elements is significant and shall be preserved when processing the array.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 73, 1))
_Namespace_gml.addCategoryObject('elementBinding', segments.name().localName(), segments)

AffinePlacement = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'AffinePlacement'), AffinePlacementType, documentation='location, refDirection, inDimension and outDimension have the same meaning as specified in ISO 19107:2003, 6.4.21.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 441, 1))
_Namespace_gml.addCategoryObject('elementBinding', AffinePlacement.name().localName(), AffinePlacement)

AbstractSurfacePatch = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractSurfacePatch'), AbstractSurfacePatchType, abstract=pyxb.binding.datatypes.boolean(1), documentation='A surface patch defines a homogenuous portion of a surface. \nThe AbstractSurfacePatch element is the abstract head of the substituition group for all surface patch elements describing a continuous portion of a surface.\nAll surface patches shall have an attribute interpolation (declared in the types derived from gml:AbstractSurfacePatchType) specifying the interpolation mechanism used for the patch using gml:SurfaceInterpolationType.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 534, 1))
_Namespace_gml.addCategoryObject('elementBinding', AbstractSurfacePatch.name().localName(), AbstractSurfacePatch)

patches = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'patches'), SurfacePatchArrayPropertyType, documentation='The patches property element contains the sequence of surface patches. The order of the elements is significant and shall be preserved when processing the array.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 549, 1))
_Namespace_gml.addCategoryObject('elementBinding', patches.name().localName(), patches)

AbstractGML = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractGML'), AbstractGMLType, abstract=pyxb.binding.datatypes.boolean(1), documentation='The abstract element gml:AbstractGML is "any GML object having identity".   It acts as the head of an XML Schema substitution group, which may include any element which is a GML feature, or other object, with identity.  This is used as a variable in content models in GML core and application schemas.  It is effectively an abstract superclass for all GML objects.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 26, 1))
_Namespace_gml.addCategoryObject('elementBinding', AbstractGML.name().localName(), AbstractGML)

abstractInlineProperty = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'abstractInlineProperty'), InlinePropertyType, abstract=pyxb.binding.datatypes.boolean(1), documentation='gml:abstractInlineProperty may be used as the head of a subtitution group of more specific elements providing a value inline.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 101, 1))
_Namespace_gml.addCategoryObject('elementBinding', abstractInlineProperty.name().localName(), abstractInlineProperty)

name = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'name'), CodeType, documentation='The gml:name property provides a label or identifier for the object, commonly a descriptive name. An object may have several names, typically assigned by different authorities. gml:name uses the gml:CodeType content model.  The authority for a name is indicated by the value of its (optional) codeSpace attribute.  The name may or may not be unique, as determined by the rules of the organization responsible for the codeSpace.  In common usage there will be one name per authority, so a processing application may select the name from its preferred codeSpace.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 127, 1))
_Namespace_gml.addCategoryObject('elementBinding', name.name().localName(), name)

topoPointProperty = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'topoPointProperty'), TopoPointPropertyType, documentation='The gml:topoPointProperty property element may be used in features to express their relationship to the referenced topology node.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/topology.xsd', 235, 2))
_Namespace_gml.addCategoryObject('elementBinding', topoPointProperty.name().localName(), topoPointProperty)

topoCurveProperty = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'topoCurveProperty'), TopoCurvePropertyType, documentation='The gml:topoCurveProperty property element may be used in features to express their relationship to the referenced topology edges.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/topology.xsd', 262, 2))
_Namespace_gml.addCategoryObject('elementBinding', topoCurveProperty.name().localName(), topoCurveProperty)

topoSurfaceProperty = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'topoSurfaceProperty'), TopoSurfacePropertyType, documentation='The gml:topoSurfaceProperty property element may be used in features to express their relationship to the referenced topology faces.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/topology.xsd', 288, 2))
_Namespace_gml.addCategoryObject('elementBinding', topoSurfaceProperty.name().localName(), topoSurfaceProperty)

topoVolumeProperty = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'topoVolumeProperty'), TopoVolumePropertyType, documentation='The gml:topoVolumeProperty element may be used in features to express their relationship to the referenced topology volume.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/topology.xsd', 314, 2))
_Namespace_gml.addCategoryObject('elementBinding', topoVolumeProperty.name().localName(), topoVolumeProperty)

topoPrimitiveMembers = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'topoPrimitiveMembers'), TopoPrimitiveArrayAssociationType, documentation='The gml:topoPrimitiveMembers property element encodes the relationship between a topology complex and an arbitrary number of topology primitives.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/topology.xsd', 369, 2))
_Namespace_gml.addCategoryObject('elementBinding', topoPrimitiveMembers.name().localName(), topoPrimitiveMembers)

catalogSymbol = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'catalogSymbol'), CodeType, documentation='The catalogSymbol is the preferred lexical symbol used for this unit of measure.\nThe codeSpace attribute in gml:CodeType identifies a namespace for the catalog symbol value, and might reference the external catalog. The string value in gml:CodeType contains the value of a symbol that should be unique within this catalog namespace. This symbol often appears explicitly in the catalog, but it could be a combination of symbols using a specified algebra of units.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/units.xsd', 59, 1))
_Namespace_gml.addCategoryObject('elementBinding', catalogSymbol.name().localName(), catalogSymbol)

valueComponents = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'valueComponents'), ValueArrayPropertyType, documentation='Property that contains Values.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/valueObjects.xsd', 114, 1))
_Namespace_gml.addCategoryObject('elementBinding', valueComponents.name().localName(), valueComponents)

TypeName = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gco, 'TypeName'), TypeName_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 30, 1))
_Namespace_gco.addCategoryObject('elementBinding', TypeName.name().localName(), TypeName)

MemberName = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gco, 'MemberName'), MemberName_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 54, 1))
_Namespace_gco.addCategoryObject('elementBinding', MemberName.name().localName(), MemberName)

Multiplicity = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gco, 'Multiplicity'), Multiplicity_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 77, 1))
_Namespace_gco.addCategoryObject('elementBinding', Multiplicity.name().localName(), Multiplicity)

MultiplicityRange = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gco, 'MultiplicityRange'), MultiplicityRange_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 101, 1))
_Namespace_gco.addCategoryObject('elementBinding', MultiplicityRange.name().localName(), MultiplicityRange)

RecordType = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gco, 'RecordType'), RecordType_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 400, 1))
_Namespace_gco.addCategoryObject('elementBinding', RecordType.name().localName(), RecordType)

MD_ApplicationSchemaInformation = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_ApplicationSchemaInformation'), MD_ApplicationSchemaInformation_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/applicationSchema.xsd', 33, 1))
_Namespace_gmd.addCategoryObject('elementBinding', MD_ApplicationSchemaInformation.name().localName(), MD_ApplicationSchemaInformation)

CI_ResponsibleParty = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'CI_ResponsibleParty'), CI_ResponsibleParty_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 31, 1))
_Namespace_gmd.addCategoryObject('elementBinding', CI_ResponsibleParty.name().localName(), CI_ResponsibleParty)

CI_Citation = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'CI_Citation'), CI_Citation_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 66, 1))
_Namespace_gmd.addCategoryObject('elementBinding', CI_Citation.name().localName(), CI_Citation)

CI_Address = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'CI_Address'), CI_Address_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 94, 1))
_Namespace_gmd.addCategoryObject('elementBinding', CI_Address.name().localName(), CI_Address)

CI_OnlineResource = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'CI_OnlineResource'), CI_OnlineResource_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 122, 1))
_Namespace_gmd.addCategoryObject('elementBinding', CI_OnlineResource.name().localName(), CI_OnlineResource)

CI_Contact = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'CI_Contact'), CI_Contact_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 149, 1))
_Namespace_gmd.addCategoryObject('elementBinding', CI_Contact.name().localName(), CI_Contact)

CI_Telephone = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'CI_Telephone'), CI_Telephone_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 173, 1))
_Namespace_gmd.addCategoryObject('elementBinding', CI_Telephone.name().localName(), CI_Telephone)

CI_Date = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'CI_Date'), CI_Date_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 194, 1))
_Namespace_gmd.addCategoryObject('elementBinding', CI_Date.name().localName(), CI_Date)

CI_Series = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'CI_Series'), CI_Series_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 216, 1))
_Namespace_gmd.addCategoryObject('elementBinding', CI_Series.name().localName(), CI_Series)

MD_Constraints = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_Constraints'), MD_Constraints_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/constraints.xsd', 26, 1))
_Namespace_gmd.addCategoryObject('elementBinding', MD_Constraints.name().localName(), MD_Constraints)

AbstractMD_ContentInformation = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'AbstractMD_ContentInformation'), AbstractMD_ContentInformation_Type, abstract=pyxb.binding.datatypes.boolean(1), location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/content.xsd', 109, 1))
_Namespace_gmd.addCategoryObject('elementBinding', AbstractMD_ContentInformation.name().localName(), AbstractMD_ContentInformation)

MD_RangeDimension = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_RangeDimension'), MD_RangeDimension_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/content.xsd', 133, 1))
_Namespace_gmd.addCategoryObject('elementBinding', MD_RangeDimension.name().localName(), MD_RangeDimension)

LI_ProcessStep = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'LI_ProcessStep'), LI_ProcessStep_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 29, 1))
_Namespace_gmd.addCategoryObject('elementBinding', LI_ProcessStep.name().localName(), LI_ProcessStep)

LI_Source = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'LI_Source'), LI_Source_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 54, 1))
_Namespace_gmd.addCategoryObject('elementBinding', LI_Source.name().localName(), LI_Source)

LI_Lineage = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'LI_Lineage'), LI_Lineage_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 76, 1))
_Namespace_gmd.addCategoryObject('elementBinding', LI_Lineage.name().localName(), LI_Lineage)

AbstractDQ_Result = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'AbstractDQ_Result'), AbstractDQ_Result_Type, abstract=pyxb.binding.datatypes.boolean(1), location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 145, 1))
_Namespace_gmd.addCategoryObject('elementBinding', AbstractDQ_Result.name().localName(), AbstractDQ_Result)

AbstractDQ_Element = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'AbstractDQ_Element'), AbstractDQ_Element_Type, abstract=pyxb.binding.datatypes.boolean(1), location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 492, 1))
_Namespace_gmd.addCategoryObject('elementBinding', AbstractDQ_Element.name().localName(), AbstractDQ_Element)

DQ_DataQuality = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'DQ_DataQuality'), DQ_DataQuality_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 514, 1))
_Namespace_gmd.addCategoryObject('elementBinding', DQ_DataQuality.name().localName(), DQ_DataQuality)

DQ_Scope = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'DQ_Scope'), DQ_Scope_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 536, 1))
_Namespace_gmd.addCategoryObject('elementBinding', DQ_Scope.name().localName(), DQ_Scope)

MD_Medium = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_Medium'), MD_Medium_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/distribution.xsd', 32, 1))
_Namespace_gmd.addCategoryObject('elementBinding', MD_Medium.name().localName(), MD_Medium)

MD_DigitalTransferOptions = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_DigitalTransferOptions'), MD_DigitalTransferOptions_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/distribution.xsd', 58, 1))
_Namespace_gmd.addCategoryObject('elementBinding', MD_DigitalTransferOptions.name().localName(), MD_DigitalTransferOptions)

MD_StandardOrderProcess = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_StandardOrderProcess'), MD_StandardOrderProcess_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/distribution.xsd', 84, 1))
_Namespace_gmd.addCategoryObject('elementBinding', MD_StandardOrderProcess.name().localName(), MD_StandardOrderProcess)

MD_Distributor = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_Distributor'), MD_Distributor_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/distribution.xsd', 110, 1))
_Namespace_gmd.addCategoryObject('elementBinding', MD_Distributor.name().localName(), MD_Distributor)

MD_Distribution = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_Distribution'), MD_Distribution_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/distribution.xsd', 135, 1))
_Namespace_gmd.addCategoryObject('elementBinding', MD_Distribution.name().localName(), MD_Distribution)

MD_Format = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_Format'), MD_Format_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/distribution.xsd', 163, 1))
_Namespace_gmd.addCategoryObject('elementBinding', MD_Format.name().localName(), MD_Format)

EX_TemporalExtent = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'EX_TemporalExtent'), EX_TemporalExtent_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/extent.xsd', 30, 1))
_Namespace_gmd.addCategoryObject('elementBinding', EX_TemporalExtent.name().localName(), EX_TemporalExtent)

EX_VerticalExtent = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'EX_VerticalExtent'), EX_VerticalExtent_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/extent.xsd', 55, 1))
_Namespace_gmd.addCategoryObject('elementBinding', EX_VerticalExtent.name().localName(), EX_VerticalExtent)

EX_Extent = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'EX_Extent'), EX_Extent_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/extent.xsd', 104, 1))
_Namespace_gmd.addCategoryObject('elementBinding', EX_Extent.name().localName(), EX_Extent)

AbstractEX_GeographicExtent = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'AbstractEX_GeographicExtent'), AbstractEX_GeographicExtent_Type, abstract=pyxb.binding.datatypes.boolean(1), location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/extent.xsd', 127, 1))
_Namespace_gmd.addCategoryObject('elementBinding', AbstractEX_GeographicExtent.name().localName(), AbstractEX_GeographicExtent)

PT_FreeText = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'PT_FreeText'), PT_FreeText_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/freeText.xsd', 24, 1))
_Namespace_gmd.addCategoryObject('elementBinding', PT_FreeText.name().localName(), PT_FreeText)

PT_Locale = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'PT_Locale'), PT_Locale_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/freeText.xsd', 48, 1))
_Namespace_gmd.addCategoryObject('elementBinding', PT_Locale.name().localName(), PT_Locale)

AbstractMD_Identification = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'AbstractMD_Identification'), AbstractMD_Identification_Type, abstract=pyxb.binding.datatypes.boolean(1), location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 41, 1))
_Namespace_gmd.addCategoryObject('elementBinding', AbstractMD_Identification.name().localName(), AbstractMD_Identification)

MD_BrowseGraphic = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_BrowseGraphic'), MD_BrowseGraphic_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 66, 1))
_Namespace_gmd.addCategoryObject('elementBinding', MD_BrowseGraphic.name().localName(), MD_BrowseGraphic)

MD_RepresentativeFraction = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_RepresentativeFraction'), MD_RepresentativeFraction_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 132, 1))
_Namespace_gmd.addCategoryObject('elementBinding', MD_RepresentativeFraction.name().localName(), MD_RepresentativeFraction)

MD_Usage = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_Usage'), MD_Usage_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 158, 1))
_Namespace_gmd.addCategoryObject('elementBinding', MD_Usage.name().localName(), MD_Usage)

MD_Keywords = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_Keywords'), MD_Keywords_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 183, 1))
_Namespace_gmd.addCategoryObject('elementBinding', MD_Keywords.name().localName(), MD_Keywords)

DS_Association = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'DS_Association'), DS_Association_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 201, 1))
_Namespace_gmd.addCategoryObject('elementBinding', DS_Association.name().localName(), DS_Association)

MD_AggregateInformation = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_AggregateInformation'), MD_AggregateInformation_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 227, 1))
_Namespace_gmd.addCategoryObject('elementBinding', MD_AggregateInformation.name().localName(), MD_AggregateInformation)

MD_MaintenanceInformation = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_MaintenanceInformation'), MD_MaintenanceInformation_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/maintenance.xsd', 34, 1))
_Namespace_gmd.addCategoryObject('elementBinding', MD_MaintenanceInformation.name().localName(), MD_MaintenanceInformation)

AbstractDS_Aggregate = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'AbstractDS_Aggregate'), AbstractDS_Aggregate_Type, abstract=pyxb.binding.datatypes.boolean(1), location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataApplication.xsd', 30, 1))
_Namespace_gmd.addCategoryObject('elementBinding', AbstractDS_Aggregate.name().localName(), AbstractDS_Aggregate)

DS_DataSet = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'DS_DataSet'), DS_DataSet_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataApplication.xsd', 54, 1))
_Namespace_gmd.addCategoryObject('elementBinding', DS_DataSet.name().localName(), DS_DataSet)

MD_Metadata = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_Metadata'), MD_Metadata_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataEntity.xsd', 61, 1))
_Namespace_gmd.addCategoryObject('elementBinding', MD_Metadata.name().localName(), MD_Metadata)

MD_ExtendedElementInformation = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_ExtendedElementInformation'), MD_ExtendedElementInformation_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataExtension.xsd', 39, 1))
_Namespace_gmd.addCategoryObject('elementBinding', MD_ExtendedElementInformation.name().localName(), MD_ExtendedElementInformation)

MD_MetadataExtensionInformation = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_MetadataExtensionInformation'), MD_MetadataExtensionInformation_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataExtension.xsd', 63, 1))
_Namespace_gmd.addCategoryObject('elementBinding', MD_MetadataExtensionInformation.name().localName(), MD_MetadataExtensionInformation)

MD_PortrayalCatalogueReference = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_PortrayalCatalogueReference'), MD_PortrayalCatalogueReference_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/portrayalCatalogue.xsd', 27, 1))
_Namespace_gmd.addCategoryObject('elementBinding', MD_PortrayalCatalogueReference.name().localName(), MD_PortrayalCatalogueReference)

MD_ReferenceSystem = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_ReferenceSystem'), MD_ReferenceSystem_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/referenceSystem.xsd', 46, 1))
_Namespace_gmd.addCategoryObject('elementBinding', MD_ReferenceSystem.name().localName(), MD_ReferenceSystem)

MD_Identifier = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_Identifier'), MD_Identifier_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/referenceSystem.xsd', 67, 1))
_Namespace_gmd.addCategoryObject('elementBinding', MD_Identifier.name().localName(), MD_Identifier)

AbstractRS_ReferenceSystem = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'AbstractRS_ReferenceSystem'), AbstractRS_ReferenceSystem_Type, abstract=pyxb.binding.datatypes.boolean(1), location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/referenceSystem.xsd', 91, 1))
_Namespace_gmd.addCategoryObject('elementBinding', AbstractRS_ReferenceSystem.name().localName(), AbstractRS_ReferenceSystem)

AbstractMD_SpatialRepresentation = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'AbstractMD_SpatialRepresentation'), AbstractMD_SpatialRepresentation_Type, abstract=pyxb.binding.datatypes.boolean(1), location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/spatialRepresentation.xsd', 76, 1))
_Namespace_gmd.addCategoryObject('elementBinding', AbstractMD_SpatialRepresentation.name().localName(), AbstractMD_SpatialRepresentation)

MD_Dimension = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_Dimension'), MD_Dimension_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/spatialRepresentation.xsd', 122, 1))
_Namespace_gmd.addCategoryObject('elementBinding', MD_Dimension.name().localName(), MD_Dimension)

MD_GeometricObjects = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_GeometricObjects'), MD_GeometricObjects_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/spatialRepresentation.xsd', 169, 1))
_Namespace_gmd.addCategoryObject('elementBinding', MD_GeometricObjects.name().localName(), MD_GeometricObjects)

ParameterValue = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'ParameterValue'), ParameterValueType, documentation='gml:ParameterValue is a parameter value, an ordered sequence of values, or a reference to a file of parameter values. This concrete complex type may be used for operation methods without using an Application Schema that defines operation-method-specialized element names and contents, especially for methods with only one instance. This complex type may be used, extended, or restricted for well-known operation methods, especially for methods with many instances.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 300, 1))
_Namespace_gml.addCategoryObject('elementBinding', ParameterValue.name().localName(), ParameterValue)

ParameterValueGroup = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'ParameterValueGroup'), ParameterValueGroupType, documentation='gml:ParameterValueGroup is a group of related parameter values. The same group can be repeated more than once in a Conversion, Transformation, or higher level ParameterValueGroup, if those instances contain different values of one or more parameterValues which suitably distinquish among those groups. This concrete complex type can be used for operation methods without using an Application Schema that defines operation-method-specialized element names and contents. This complex type may be used, extended, or restricted for well-known operation methods, especially for methods with only one instance.\nThe parameterValue elements are an unordered set of composition association roles to the parameter values and groups of values included in this group.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 364, 1))
_Namespace_gml.addCategoryObject('elementBinding', ParameterValueGroup.name().localName(), ParameterValueGroup)

derivedCRSType = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'derivedCRSType'), CodeWithAuthorityType, documentation='The gml:derivedCRSType property describes the type of a derived coordinate reference system. The required codeSpace attribute shall reference a source of information specifying the values and meanings of all the allowed string values for this property.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateReferenceSystems.xsd', 215, 1))
_Namespace_gml.addCategoryObject('elementBinding', derivedCRSType.name().localName(), derivedCRSType)

axisDirection = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'axisDirection'), CodeWithAuthorityType, documentation='gml:axisDirection is the direction of this coordinate system axis (or in the case of Cartesian projected coordinates, the direction of this coordinate system axis at the origin).\nWithin any set of coordinate system axes, only one of each pair of terms may be used. For earth-fixed CRSs, this direction is often approximate and intended to provide a human interpretable meaning to the axis. When a geodetic datum is used, the precise directions of the axes may therefore vary slightly from this approximate direction.\nThe codeSpace attribute shall reference a source of information specifying the values and meanings of all the allowed string values for this property.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateSystems.xsd', 47, 1))
_Namespace_gml.addCategoryObject('elementBinding', axisDirection.name().localName(), axisDirection)

rangeMeaning = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'rangeMeaning'), CodeWithAuthorityType, documentation='gml:rangeMeaning describes the meaning of axis value range specified by gml:minimumValue and gml:maximumValue. This element shall be omitted when both gml:minimumValue and gml:maximumValue are omitted. This element should be included when gml:minimumValue and/or gml:maximumValue are included. If this element is omitted when the gml:minimumValue and/or gml:maximumValue are included, the meaning is unspecified. The codeSpace attribute shall reference a source of information specifying the values and meanings of all the allowed string values for this property.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateSystems.xsd', 64, 1))
_Namespace_gml.addCategoryObject('elementBinding', rangeMeaning.name().localName(), rangeMeaning)

pixelInCell = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'pixelInCell'), CodeWithAuthorityType, documentation='gml:pixelInCell is a specification of the way an image grid is associated with the image data attributes. The required codeSpace attribute shall reference a source of information specifying the values and meanings of all the allowed string values for this property.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/datums.xsd', 206, 1))
_Namespace_gml.addCategoryObject('elementBinding', pixelInCell.name().localName(), pixelInCell)

Null = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'Null'), NilReasonType, documentation='', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 13, 1))
_Namespace_gml.addCategoryObject('elementBinding', Null.name().localName(), Null)

degrees = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'degrees'), DegreesType, documentation='', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 554, 1))
_Namespace_gml.addCategoryObject('elementBinding', degrees.name().localName(), degrees)

Bag = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'Bag'), BagType, documentation='', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 677, 1))
_Namespace_gml.addCategoryObject('elementBinding', Bag.name().localName(), Bag)

Array = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'Array'), ArrayType, documentation='', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 695, 1))
_Namespace_gml.addCategoryObject('elementBinding', Array.name().localName(), Array)

GenericMetaData = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'GenericMetaData'), GenericMetaDataType, documentation='', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 734, 1))
_Namespace_gml.addCategoryObject('elementBinding', GenericMetaData.name().localName(), GenericMetaData)

AbstractTimeSlice = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractTimeSlice'), AbstractTimeSliceType, abstract=pyxb.binding.datatypes.boolean(1), documentation='To describe an event — an action that occurs at an instant or over an interval of time — GML provides the gml:AbtractTimeSlice element. A timeslice encapsulates the time-varying properties of a dynamic feature -- it shall be extended to represent a time stamped projection of a specific feature. The gml:dataSource property describes how the temporal data was acquired.\nA gml:AbstractTimeSlice instance is a GML object that encapsulates updates of the dynamic—or volatile—properties that reflect some change event; it thus includes only those feature properties that have actually changed due to some process.\ngml:AbstractTimeSlice basically provides a facility for attribute-level time stamping, in contrast to the object-level time stamping of dynamic feature instances. \nThe time slice can thus be viewed as event or process-oriented, whereas a snapshot is more state or structure-oriented. A timeslice has richer causality, whereas a snapshot merely portrays the status of the whole. \n', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dynamicFeature.xsd', 78, 1))
_Namespace_gml.addCategoryObject('elementBinding', AbstractTimeSlice.name().localName(), AbstractTimeSlice)

AbstractFeature = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractFeature'), AbstractFeatureType, abstract=pyxb.binding.datatypes.boolean(1), documentation='This abstract element serves as the head of a substitution group which may contain any elements whose content model is derived from gml:AbstractFeatureType.  This may be used as a variable in the construction of content models.  \ngml:AbstractFeature may be thought of as "anything that is a GML feature" and may be used to define variables or templates in which the value of a GML property is "any feature". This occurs in particular in a GML feature collection where the feature member properties contain one or multiple copies of gml:AbstractFeature respectively.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/feature.xsd', 32, 1))
_Namespace_gml.addCategoryObject('elementBinding', AbstractFeature.name().localName(), AbstractFeature)

AbstractGeometry = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractGeometry'), AbstractGeometryType, abstract=pyxb.binding.datatypes.boolean(1), documentation='The AbstractGeometry element is the abstract head of the substitution group for all geometry elements of GML. This includes pre-defined and user-defined geometry elements. Any geometry element shall be a direct or indirect extension/restriction of AbstractGeometryType and shall be directly or indirectly in the substitution group of AbstractGeometry.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic0d1d.xsd', 50, 1))
_Namespace_gml.addCategoryObject('elementBinding', AbstractGeometry.name().localName(), AbstractGeometry)

pos = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'pos'), DirectPositionType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic0d1d.xsd', 87, 1))
_Namespace_gml.addCategoryObject('elementBinding', pos.name().localName(), pos)

posList = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'posList'), DirectPositionListType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic0d1d.xsd', 102, 1))
_Namespace_gml.addCategoryObject('elementBinding', posList.name().localName(), posList)

Envelope = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'Envelope'), EnvelopeType, documentation='Envelope defines an extent using a pair of positions defining opposite corners in arbitrary dimensions. The first direct position is the "lower corner" (a coordinate position consisting of all the minimal ordinates for each dimension for all points within the envelope), the second one the "upper corner" (a coordinate position consisting of all the maximal ordinates for each dimension for all points within the envelope).\nThe use of the properties "coordinates" and "pos" has been deprecated. The explicitly named properties "lowerCorner" and "upperCorner" shall be used instead.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic0d1d.xsd', 148, 1))
_Namespace_gml.addCategoryObject('elementBinding', Envelope.name().localName(), Envelope)

LineStringSegment = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'LineStringSegment'), LineStringSegmentType, documentation='A LineStringSegment is a curve segment that is defined by two or more control points including the start and end point, with linear interpolation between them.\nThe content model follows the general pattern for the encoding of curve segments.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 114, 1))
_Namespace_gml.addCategoryObject('elementBinding', LineStringSegment.name().localName(), LineStringSegment)

ArcString = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'ArcString'), ArcStringType, documentation='An ArcString is a curve segment that uses three-point circular arc interpolation ("circularArc3Points"). The number of arcs in the arc string may be explicitly stated in the attribute numArc. The number of control points in the arc string shall be 2 * numArc + 1.\nThe content model follows the general pattern for the encoding of curve segments.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 139, 1))
_Namespace_gml.addCategoryObject('elementBinding', ArcString.name().localName(), ArcString)

ArcStringByBulge = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'ArcStringByBulge'), ArcStringByBulgeType, documentation='This variant of the arc computes the mid points of the arcs instead of storing the coordinates directly. The control point sequence consists of the start and end points of each arc plus the bulge (see ISO 19107:2003, 6.4.17.2). The normal is a vector normal (perpendicular) to the chord of the arc (see ISO 19107:2003, 6.4.17.4).\nThe interpolation is fixed as "circularArc2PointWithBulge".\nThe number of arcs in the arc string may be explicitly stated in the attribute numArc. The number of control points in the arc string shall be numArc + 1.\nThe content model follows the general pattern for the encoding of curve segments.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 199, 1))
_Namespace_gml.addCategoryObject('elementBinding', ArcStringByBulge.name().localName(), ArcStringByBulge)

ArcByCenterPoint = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'ArcByCenterPoint'), ArcByCenterPointType, documentation='This variant of the arc requires that the points on the arc shall be computed instead of storing the coordinates directly. The single control point is the center point of the arc plus the radius and the bearing at start and end. This representation can be used only in 2D.\nThe element radius specifies the radius of the arc.\nThe element startAngle specifies the bearing of the arc at the start.\nThe element endAngle specifies the bearing of the arc at the end.\nThe interpolation is fixed as "circularArcCenterPointWithRadius".\nSince this type describes always a single arc, the attribute "numArc" is fixed to "1".\nThe content model follows the general pattern for the encoding of curve segments.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 255, 1))
_Namespace_gml.addCategoryObject('elementBinding', ArcByCenterPoint.name().localName(), ArcByCenterPoint)

CubicSpline = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'CubicSpline'), CubicSplineType, documentation='The number of control points shall be at least three.\nvectorAtStart is the unit tangent vector at the start point of the spline. vectorAtEnd is the unit tangent vector at the end point of the spline. Only the direction of the vectors shall be used to determine the shape of the cubic spline, not their length.\ninterpolation is fixed as "cubicSpline".\ndegree shall be the degree of the polynomial used for the interpolation in this spline. Therefore the degree for a cubic spline is fixed to "3".\nThe content model follows the general pattern for the encoding of curve segments.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 310, 1))
_Namespace_gml.addCategoryObject('elementBinding', CubicSpline.name().localName(), CubicSpline)

BSpline = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'BSpline'), BSplineType, documentation='A B-Spline is a piecewise parametric polynomial or rational curve described in terms of control points and basis functions as specified in ISO 19107:2003, 6.4.30. Therefore, interpolation may be either "polynomialSpline" or "rationalSpline" depending on the interpolation type; default is "polynomialSpline".\ndegree shall be the degree of the polynomial used for interpolation in this spline.\nknot shall be the sequence of distinct knots used to define the spline basis functions (see ISO 19107:2003, 6.4.26.2).\nThe attribute isPolynomial shall be set to "true" if this is a polynomial spline (see ISO 19107:2003, 6.4.30.5).\nThe attribute knotType shall provide the type of knot distribution used in defining this spline (see ISO 19107:2003, 6.4.30.4).\nThe content model follows the general pattern for the encoding of curve segments.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 341, 1))
_Namespace_gml.addCategoryObject('elementBinding', BSpline.name().localName(), BSpline)

OffsetCurve = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'OffsetCurve'), OffsetCurveType, documentation='An offset curve is a curve at a constant distance from the basis curve. offsetBase is the base curve from which this curve is defined as an offset. distance and refDirection have the same meaning as specified in ISO 19107:2003, 6.4.23.\nThe content model follows the general pattern for the encoding of curve segments.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 427, 1))
_Namespace_gml.addCategoryObject('elementBinding', OffsetCurve.name().localName(), OffsetCurve)

Clothoid = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'Clothoid'), ClothoidType, documentation='A clothoid, or Cornu\'s spiral, is plane curve whose curvature is a fixed function of its length.\nrefLocation, startParameter, endParameter and scaleFactor have the same meaning as specified in ISO 19107:2003, 6.4.22.\ninterpolation is fixed as "clothoid".\nThe content model follows the general pattern for the encoding of curve segments.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 465, 1))
_Namespace_gml.addCategoryObject('elementBinding', Clothoid.name().localName(), Clothoid)

GeodesicString = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'GeodesicString'), GeodesicStringType, documentation='A sequence of geodesic segments. \nThe number of control points shall be at least two.\ninterpolation is fixed as "geodesic".\nThe content model follows the general pattern for the encoding of curve segments.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 484, 1))
_Namespace_gml.addCategoryObject('elementBinding', GeodesicString.name().localName(), GeodesicString)

PolygonPatch = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'PolygonPatch'), PolygonPatchType, documentation='A gml:PolygonPatch is a surface patch that is defined by a set of boundary curves and an underlying surface to which these curves adhere. The curves shall be coplanar and the polygon uses planar interpolation in its interior. \ninterpolation is fixed to "planar", i.e. an interpolation shall return points on a single plane. The boundary of the patch shall be contained within that plane.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 582, 1))
_Namespace_gml.addCategoryObject('elementBinding', PolygonPatch.name().localName(), PolygonPatch)

Triangle = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'Triangle'), TriangleType, documentation='gml:Triangle represents a triangle as a surface patch with an outer boundary consisting of a linear ring. Note that this is a polygon (subtype) with no inner boundaries. The number of points in the linear ring shall be four.\nThe ring (element exterior) shall be a gml:LinearRing and shall form a triangle, the first and the last position shall be coincident.\ninterpolation is fixed to "planar", i.e. an interpolation shall return points on a single plane. The boundary of the patch shall be contained within that plane.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 598, 1))
_Namespace_gml.addCategoryObject('elementBinding', Triangle.name().localName(), Triangle)

Rectangle = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'Rectangle'), RectangleType, documentation='gml:Rectangle represents a rectangle as a surface patch with an outer boundary consisting of a linear ring. Note that this is a polygon (subtype) with no inner boundaries. The number of points in the linear ring shall be five.\nThe ring (element exterior) shall be a gml:LinearRing and shall form a rectangle; the first and the last position shall be coincident.\ninterpolation is fixed to "planar", i.e. an interpolation shall return points on a single plane. The boundary of the patch shall be contained within that plane.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 615, 1))
_Namespace_gml.addCategoryObject('elementBinding', Rectangle.name().localName(), Rectangle)

AbstractParametricCurveSurface = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractParametricCurveSurface'), AbstractParametricCurveSurfaceType, abstract=pyxb.binding.datatypes.boolean(1), documentation='The element provides a substitution group head for the surface patches based on parametric curves. All properties are specified in the derived subtypes. All derived subtypes shall conform to the constraints specified in ISO 19107:2003, 6.4.40.\nIf provided, the aggregationType attribute shall have the value "set".', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 673, 1))
_Namespace_gml.addCategoryObject('elementBinding', AbstractParametricCurveSurface.name().localName(), AbstractParametricCurveSurface)

identifier = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'identifier'), CodeWithAuthorityType, documentation='Often, a special identifier is assigned to an object by the maintaining authority with the intention that it is used in references to the object For such cases, the codeSpace shall be provided. That identifier is usually unique either globally or within an application domain. gml:identifier is a pre-defined property for such identifiers.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 132, 1))
_Namespace_gml.addCategoryObject('elementBinding', identifier.name().localName(), identifier)

AbstractImplicitGeometry = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractImplicitGeometry'), AbstractGeometryType, abstract=pyxb.binding.datatypes.boolean(1), location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/grids.xsd', 22, 1))
_Namespace_gml.addCategoryObject('elementBinding', AbstractImplicitGeometry.name().localName(), AbstractImplicitGeometry)

AbstractTimeObject = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractTimeObject'), AbstractTimeObjectType, abstract=pyxb.binding.datatypes.boolean(1), documentation='gml:AbstractTimeObject acts as the head of a substitution group for all temporal primitives and complexes.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporal.xsd', 18, 1))
_Namespace_gml.addCategoryObject('elementBinding', AbstractTimeObject.name().localName(), AbstractTimeObject)

timePosition = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'timePosition'), TimePositionType, documentation='This element is used directly as a property of gml:TimeInstant (see 15.2.2.3), and may also be used in application schemas.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporal.xsd', 215, 1))
_Namespace_gml.addCategoryObject('elementBinding', timePosition.name().localName(), timePosition)

AbstractTopology = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractTopology'), AbstractTopologyType, abstract=pyxb.binding.datatypes.boolean(1), location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/topology.xsd', 25, 2))
_Namespace_gml.addCategoryObject('elementBinding', AbstractTopology.name().localName(), AbstractTopology)

CompositeValue = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'CompositeValue'), CompositeValueType, documentation='gml:CompositeValue is an aggregate value built from other values . It contains zero or an arbitrary number of gml:valueComponent elements, and zero or one gml:valueComponents property elements.  It may be used for strongly coupled aggregates (vectors, tensors) or for arbitrary collections of values.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/valueObjects.xsd', 125, 1))
_Namespace_gml.addCategoryObject('elementBinding', CompositeValue.name().localName(), CompositeValue)

Measure = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gco, 'Measure'), MeasureType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 113, 1))
_Namespace_gco.addCategoryObject('elementBinding', Measure.name().localName(), Measure)

MD_LegalConstraints = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_LegalConstraints'), MD_LegalConstraints_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/constraints.xsd', 51, 1))
_Namespace_gmd.addCategoryObject('elementBinding', MD_LegalConstraints.name().localName(), MD_LegalConstraints)

MD_SecurityConstraints = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_SecurityConstraints'), MD_SecurityConstraints_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/constraints.xsd', 77, 1))
_Namespace_gmd.addCategoryObject('elementBinding', MD_SecurityConstraints.name().localName(), MD_SecurityConstraints)

MD_FeatureCatalogueDescription = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_FeatureCatalogueDescription'), MD_FeatureCatalogueDescription_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/content.xsd', 32, 1))
_Namespace_gmd.addCategoryObject('elementBinding', MD_FeatureCatalogueDescription.name().localName(), MD_FeatureCatalogueDescription)

MD_CoverageDescription = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_CoverageDescription'), MD_CoverageDescription_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/content.xsd', 57, 1))
_Namespace_gmd.addCategoryObject('elementBinding', MD_CoverageDescription.name().localName(), MD_CoverageDescription)

MD_Band = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_Band'), MD_Band_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/content.xsd', 160, 1))
_Namespace_gmd.addCategoryObject('elementBinding', MD_Band.name().localName(), MD_Band)

DQ_ConformanceResult = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'DQ_ConformanceResult'), DQ_ConformanceResult_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 101, 1))
_Namespace_gmd.addCategoryObject('elementBinding', DQ_ConformanceResult.name().localName(), DQ_ConformanceResult)

DQ_QuantitativeResult = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'DQ_QuantitativeResult'), DQ_QuantitativeResult_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 127, 1))
_Namespace_gmd.addCategoryObject('elementBinding', DQ_QuantitativeResult.name().localName(), DQ_QuantitativeResult)

AbstractDQ_TemporalAccuracy = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'AbstractDQ_TemporalAccuracy'), AbstractDQ_TemporalAccuracy_Type, abstract=pyxb.binding.datatypes.boolean(1), location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 401, 1))
_Namespace_gmd.addCategoryObject('elementBinding', AbstractDQ_TemporalAccuracy.name().localName(), AbstractDQ_TemporalAccuracy)

AbstractDQ_ThematicAccuracy = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'AbstractDQ_ThematicAccuracy'), AbstractDQ_ThematicAccuracy_Type, abstract=pyxb.binding.datatypes.boolean(1), location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 417, 1))
_Namespace_gmd.addCategoryObject('elementBinding', AbstractDQ_ThematicAccuracy.name().localName(), AbstractDQ_ThematicAccuracy)

AbstractDQ_PositionalAccuracy = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'AbstractDQ_PositionalAccuracy'), AbstractDQ_PositionalAccuracy_Type, abstract=pyxb.binding.datatypes.boolean(1), location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 433, 1))
_Namespace_gmd.addCategoryObject('elementBinding', AbstractDQ_PositionalAccuracy.name().localName(), AbstractDQ_PositionalAccuracy)

AbstractDQ_LogicalConsistency = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'AbstractDQ_LogicalConsistency'), AbstractDQ_LogicalConsistency_Type, abstract=pyxb.binding.datatypes.boolean(1), location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 449, 1))
_Namespace_gmd.addCategoryObject('elementBinding', AbstractDQ_LogicalConsistency.name().localName(), AbstractDQ_LogicalConsistency)

AbstractDQ_Completeness = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'AbstractDQ_Completeness'), AbstractDQ_Completeness_Type, abstract=pyxb.binding.datatypes.boolean(1), location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 465, 1))
_Namespace_gmd.addCategoryObject('elementBinding', AbstractDQ_Completeness.name().localName(), AbstractDQ_Completeness)

EX_BoundingPolygon = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'EX_BoundingPolygon'), EX_BoundingPolygon_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/extent.xsd', 78, 1))
_Namespace_gmd.addCategoryObject('elementBinding', EX_BoundingPolygon.name().localName(), EX_BoundingPolygon)

EX_GeographicBoundingBox = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'EX_GeographicBoundingBox'), EX_GeographicBoundingBox_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/extent.xsd', 153, 1))
_Namespace_gmd.addCategoryObject('elementBinding', EX_GeographicBoundingBox.name().localName(), EX_GeographicBoundingBox)

EX_SpatialTemporalExtent = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'EX_SpatialTemporalExtent'), EX_SpatialTemporalExtent_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/extent.xsd', 176, 1))
_Namespace_gmd.addCategoryObject('elementBinding', EX_SpatialTemporalExtent.name().localName(), EX_SpatialTemporalExtent)

EX_GeographicDescription = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'EX_GeographicDescription'), EX_GeographicDescription_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/extent.xsd', 196, 1))
_Namespace_gmd.addCategoryObject('elementBinding', EX_GeographicDescription.name().localName(), EX_GeographicDescription)

MD_DataIdentification = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_DataIdentification'), MD_DataIdentification_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 93, 1))
_Namespace_gmd.addCategoryObject('elementBinding', MD_DataIdentification.name().localName(), MD_DataIdentification)

MD_ServiceIdentification = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_ServiceIdentification'), MD_ServiceIdentification_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 112, 1))
_Namespace_gmd.addCategoryObject('elementBinding', MD_ServiceIdentification.name().localName(), MD_ServiceIdentification)

DS_OtherAggregate = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'DS_OtherAggregate'), DS_OtherAggregate_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataApplication.xsd', 70, 1))
_Namespace_gmd.addCategoryObject('elementBinding', DS_OtherAggregate.name().localName(), DS_OtherAggregate)

DS_Series = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'DS_Series'), DS_Series_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataApplication.xsd', 86, 1))
_Namespace_gmd.addCategoryObject('elementBinding', DS_Series.name().localName(), DS_Series)

DS_Initiative = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'DS_Initiative'), DS_Initiative_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataApplication.xsd', 102, 1))
_Namespace_gmd.addCategoryObject('elementBinding', DS_Initiative.name().localName(), DS_Initiative)

RS_Identifier = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'RS_Identifier'), RS_Identifier_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/referenceSystem.xsd', 26, 1))
_Namespace_gmd.addCategoryObject('elementBinding', RS_Identifier.name().localName(), RS_Identifier)

MD_GridSpatialRepresentation = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_GridSpatialRepresentation'), MD_GridSpatialRepresentation_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/spatialRepresentation.xsd', 31, 1))
_Namespace_gmd.addCategoryObject('elementBinding', MD_GridSpatialRepresentation.name().localName(), MD_GridSpatialRepresentation)

MD_VectorSpatialRepresentation = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_VectorSpatialRepresentation'), MD_VectorSpatialRepresentation_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/spatialRepresentation.xsd', 55, 1))
_Namespace_gmd.addCategoryObject('elementBinding', MD_VectorSpatialRepresentation.name().localName(), MD_VectorSpatialRepresentation)

coordinateOperationAccuracy = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'coordinateOperationAccuracy'), CTD_ANON_6, documentation='gml:coordinateOperationAccuracy is an association role to a DQ_PositionalAccuracy object as encoded in ISO/TS 19139, either referencing or containing the definition of that positional accuracy. That object contains an estimate of the impact of this coordinate operation on point accuracy. That is, it gives position error estimates for the target coordinates of this coordinate operation, assuming no errors in the source coordinates.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 48, 1))
_Namespace_gml.addCategoryObject('elementBinding', coordinateOperationAccuracy.name().localName(), coordinateOperationAccuracy)

sourceCRS = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'sourceCRS'), CRSPropertyType, documentation='gml:sourceCRS is an association role to the source CRS (coordinate reference system) of this coordinate operation.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 59, 1))
_Namespace_gml.addCategoryObject('elementBinding', sourceCRS.name().localName(), sourceCRS)

targetCRS = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'targetCRS'), CRSPropertyType, documentation='gml:targetCRS is an association role to the target CRS (coordinate reference system) of this coordinate operation.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 64, 1))
_Namespace_gml.addCategoryObject('elementBinding', targetCRS.name().localName(), targetCRS)

coordOperation = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'coordOperation'), CoordinateOperationPropertyType, documentation='gml:coordOperation is an association role to a coordinate operation.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 176, 1))
_Namespace_gml.addCategoryObject('elementBinding', coordOperation.name().localName(), coordOperation)

method = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'method'), OperationMethodPropertyType, documentation='gml:method is an association role to the operation method used by a coordinate operation.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 238, 1))
_Namespace_gml.addCategoryObject('elementBinding', method.name().localName(), method)

value = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'value'), MeasureType, documentation='gml:value is a numeric value of an operation parameter, with its associated unit of measure.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 324, 1))
_Namespace_gml.addCategoryObject('elementBinding', value.name().localName(), value)

valueList = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'valueList'), MeasureListType, documentation='gml:valueList is an ordered sequence of two or more numeric values of an operation parameter list, where each value has the same associated unit of measure. An element of this type contains a space-separated sequence of double values.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 344, 1))
_Namespace_gml.addCategoryObject('elementBinding', valueList.name().localName(), valueList)

operationParameter = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'operationParameter'), OperationParameterPropertyType, documentation='gml:operationParameter is an association role to the operation parameter of which this is a value.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 359, 1))
_Namespace_gml.addCategoryObject('elementBinding', operationParameter.name().localName(), operationParameter)

group = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'group'), OperationParameterGroupPropertyType, documentation='gml:group is an association role to the operation parameter group for which this element provides parameter values.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 380, 1))
_Namespace_gml.addCategoryObject('elementBinding', group.name().localName(), group)

formulaCitation = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'formulaCitation'), CTD_ANON_7, documentation='gml:formulaCitation provides a reference to a publication giving the formula(s) or procedure used by an coordinate operation method.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 406, 1))
_Namespace_gml.addCategoryObject('elementBinding', formulaCitation.name().localName(), formulaCitation)

parameter = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'parameter'), AbstractGeneralOperationParameterPropertyType, documentation='gml:parameter is an association to an operation parameter or parameter group.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 432, 1))
_Namespace_gml.addCategoryObject('elementBinding', parameter.name().localName(), parameter)

conversion = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'conversion'), GeneralConversionPropertyType, documentation='gml:conversion is an association role to the coordinate conversion used to define the derived CRS.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateReferenceSystems.xsd', 46, 1))
_Namespace_gml.addCategoryObject('elementBinding', conversion.name().localName(), conversion)

componentReferenceSystem = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'componentReferenceSystem'), SingleCRSPropertyType, documentation='The gml:componentReferenceSystem elements are an ordered sequence of associations to all the component coordinate reference systems included in this compound coordinate reference system. The gml:AggregationAttributeGroup should be used to specify that the gml:componentReferenceSystem properties are ordered.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateReferenceSystems.xsd', 66, 1))
_Namespace_gml.addCategoryObject('elementBinding', componentReferenceSystem.name().localName(), componentReferenceSystem)

ellipsoidalCS = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'ellipsoidalCS'), EllipsoidalCSPropertyType, documentation='gml:ellipsoidalCS is an association role to the ellipsoidal coordinate system used by this CRS.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateReferenceSystems.xsd', 98, 1))
_Namespace_gml.addCategoryObject('elementBinding', ellipsoidalCS.name().localName(), ellipsoidalCS)

cartesianCS = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'cartesianCS'), CartesianCSPropertyType, documentation='gml:cartesianCS is an association role to the Cartesian coordinate system used by this CRS.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateReferenceSystems.xsd', 103, 1))
_Namespace_gml.addCategoryObject('elementBinding', cartesianCS.name().localName(), cartesianCS)

sphericalCS = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'sphericalCS'), SphericalCSPropertyType, documentation='gml:sphericalCS is an association role to the spherical coordinate system used by this CRS.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateReferenceSystems.xsd', 108, 1))
_Namespace_gml.addCategoryObject('elementBinding', sphericalCS.name().localName(), sphericalCS)

geodeticDatum = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'geodeticDatum'), GeodeticDatumPropertyType, documentation='gml:geodeticDatum is an association role to the geodetic datum used by this CRS.\n', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateReferenceSystems.xsd', 113, 1))
_Namespace_gml.addCategoryObject('elementBinding', geodeticDatum.name().localName(), geodeticDatum)

verticalCS = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'verticalCS'), VerticalCSPropertyType, documentation='gml:verticalCS is an association role to the vertical coordinate system used by this CRS.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateReferenceSystems.xsd', 143, 1))
_Namespace_gml.addCategoryObject('elementBinding', verticalCS.name().localName(), verticalCS)

verticalDatum = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'verticalDatum'), VerticalDatumPropertyType, documentation='gml:verticalDatum is an association role to the vertical datum used by this CRS.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateReferenceSystems.xsd', 148, 1))
_Namespace_gml.addCategoryObject('elementBinding', verticalDatum.name().localName(), verticalDatum)

baseGeodeticCRS = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'baseGeodeticCRS'), GeodeticCRSPropertyType, documentation='gml:baseGeodeticCRS is an association role to the geodetic coordinate reference system used by this projected CRS.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateReferenceSystems.xsd', 180, 1))
_Namespace_gml.addCategoryObject('elementBinding', baseGeodeticCRS.name().localName(), baseGeodeticCRS)

baseCRS = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'baseCRS'), SingleCRSPropertyType, documentation='gml:baseCRS is an association role to the coordinate reference system used by this derived CRS.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateReferenceSystems.xsd', 210, 1))
_Namespace_gml.addCategoryObject('elementBinding', baseCRS.name().localName(), baseCRS)

coordinateSystem = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'coordinateSystem'), CoordinateSystemPropertyType, documentation='An association role to the coordinate system used by this CRS.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateReferenceSystems.xsd', 220, 1))
_Namespace_gml.addCategoryObject('elementBinding', coordinateSystem.name().localName(), coordinateSystem)

cylindricalCS = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'cylindricalCS'), CylindricalCSPropertyType, documentation='gml:cylindricalCS is an association role to the cylindrical coordinate system used by this CRS.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateReferenceSystems.xsd', 264, 1))
_Namespace_gml.addCategoryObject('elementBinding', cylindricalCS.name().localName(), cylindricalCS)

linearCS = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'linearCS'), LinearCSPropertyType, documentation='gml:linearCS is an association role to the linear coordinate system used by this CRS.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateReferenceSystems.xsd', 269, 1))
_Namespace_gml.addCategoryObject('elementBinding', linearCS.name().localName(), linearCS)

polarCS = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'polarCS'), PolarCSPropertyType, documentation='gml:polarCS is an association role to the polar coordinate system used by this CRS.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateReferenceSystems.xsd', 274, 1))
_Namespace_gml.addCategoryObject('elementBinding', polarCS.name().localName(), polarCS)

userDefinedCS = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'userDefinedCS'), UserDefinedCSPropertyType, documentation='gml:userDefinedCS is an association role to the user defined coordinate system used by this CRS.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateReferenceSystems.xsd', 279, 1))
_Namespace_gml.addCategoryObject('elementBinding', userDefinedCS.name().localName(), userDefinedCS)

engineeringDatum = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'engineeringDatum'), EngineeringDatumPropertyType, documentation='gml:engineeringDatum is an association role to the engineering datum used by this CRS.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateReferenceSystems.xsd', 284, 1))
_Namespace_gml.addCategoryObject('elementBinding', engineeringDatum.name().localName(), engineeringDatum)

affineCS = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'affineCS'), AffineCSPropertyType, documentation='gml:affineCS is an association role to the affine coordinate system used by this CRS.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateReferenceSystems.xsd', 317, 1))
_Namespace_gml.addCategoryObject('elementBinding', affineCS.name().localName(), affineCS)

imageDatum = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'imageDatum'), ImageDatumPropertyType, documentation='gml:imageDatum is an association role to the image datum used by this CRS.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateReferenceSystems.xsd', 322, 1))
_Namespace_gml.addCategoryObject('elementBinding', imageDatum.name().localName(), imageDatum)

timeCS = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'timeCS'), TimeCSPropertyType, documentation='gml:timeCS is an association role to the time coordinate system used by this CRS.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateReferenceSystems.xsd', 354, 1))
_Namespace_gml.addCategoryObject('elementBinding', timeCS.name().localName(), timeCS)

temporalDatum = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'temporalDatum'), TemporalDatumPropertyType, documentation='gml:temporalDatum is an association role to the temporal datum used by this CRS.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateReferenceSystems.xsd', 359, 1))
_Namespace_gml.addCategoryObject('elementBinding', temporalDatum.name().localName(), temporalDatum)

axis = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'axis'), CoordinateSystemAxisPropertyType, documentation='The gml:axis property is an association role (ordered sequence) to the coordinate system axes included in this coordinate system. The coordinate values in a coordinate tuple shall be recorded in the order in which the coordinate system axes associations are recorded, whenever those coordinates use a coordinate reference system that uses this coordinate system. The gml:AggregationAttributeGroup should be used to specify that the axis objects are ordered.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateSystems.xsd', 93, 1))
_Namespace_gml.addCategoryObject('elementBinding', axis.name().localName(), axis)

AbstractCoverage = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractCoverage'), AbstractCoverageType, abstract=pyxb.binding.datatypes.boolean(1), documentation='This element serves as the head of a substitution group which may contain any coverage whose type is derived from gml:AbstractCoverageType.  It may act as a variable in the definition of content models where it is required to permit any coverage to be valid.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coverage.xsd', 34, 1))
_Namespace_gml.addCategoryObject('elementBinding', AbstractCoverage.name().localName(), AbstractCoverage)

domainSet = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'domainSet'), DomainSetType, documentation='The gml:domainSet property element describes the spatio-temporal region of interest, within which the coverage is defined. Its content model is given by gml:DomainSetType.\nThe value of the domain is thus a choice between a gml:AbstractGeometry and a gml:AbstractTimeObject.  In the instance these abstract elements will normally be substituted by a geometry complex or temporal complex, to represent spatial coverages and time-series, respectively.  \nThe presence of the gml:AssociationAttributeGroup means that domainSet follows the usual GML property model and may use the xlink:href attribute to point to the domain, as an alternative to describing the domain inline. Ownership semantics may be provided using the gml:OwnershipAttributeGroup.\n', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coverage.xsd', 70, 1))
_Namespace_gml.addCategoryObject('elementBinding', domainSet.name().localName(), domainSet)

rangeParameters = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'rangeParameters'), AssociationRoleType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coverage.xsd', 118, 1))
_Namespace_gml.addCategoryObject('elementBinding', rangeParameters.name().localName(), rangeParameters)

doubleOrNilReasonTupleList = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'doubleOrNilReasonTupleList'), doubleOrNilReasonList, documentation='gml:doubleOrNilReasonList consists of a list of gml:doubleOrNilReason values, each separated by a whitespace. The gml:doubleOrNilReason values are grouped into tuples where the dimension of each tuple in the list is equal to the number of range parameters.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coverage.xsd', 125, 1))
_Namespace_gml.addCategoryObject('elementBinding', doubleOrNilReasonTupleList.name().localName(), doubleOrNilReasonTupleList)

primeMeridian = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'primeMeridian'), PrimeMeridianPropertyType, documentation='gml:primeMeridian is an association role to the prime meridian used by this geodetic datum.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/datums.xsd', 76, 1))
_Namespace_gml.addCategoryObject('elementBinding', primeMeridian.name().localName(), primeMeridian)

ellipsoid = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'ellipsoid'), EllipsoidPropertyType, documentation='gml:ellipsoid is an association role to the ellipsoid used by this geodetic datum.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/datums.xsd', 81, 1))
_Namespace_gml.addCategoryObject('elementBinding', ellipsoid.name().localName(), ellipsoid)

semiMajorAxis = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'semiMajorAxis'), MeasureType, documentation='gml:semiMajorAxis specifies the length of the semi-major axis of the ellipsoid, with its units. Uses the MeasureType with the restriction that the unit of measure referenced by uom must be suitable for a length, such as metres or feet.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/datums.xsd', 110, 1))
_Namespace_gml.addCategoryObject('elementBinding', semiMajorAxis.name().localName(), semiMajorAxis)

datumRef = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'datumRef'), DatumPropertyType, documentation='', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 23, 1))
_Namespace_gml.addCategoryObject('elementBinding', datumRef.name().localName(), datumRef)

usesPrimeMeridian = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'usesPrimeMeridian'), PrimeMeridianPropertyType, documentation='', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 28, 1))
_Namespace_gml.addCategoryObject('elementBinding', usesPrimeMeridian.name().localName(), usesPrimeMeridian)

usesEllipsoid = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'usesEllipsoid'), EllipsoidPropertyType, documentation='', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 33, 1))
_Namespace_gml.addCategoryObject('elementBinding', usesEllipsoid.name().localName(), usesEllipsoid)

geodeticDatumRef = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'geodeticDatumRef'), GeodeticDatumPropertyType, documentation='', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 38, 1))
_Namespace_gml.addCategoryObject('elementBinding', geodeticDatumRef.name().localName(), geodeticDatumRef)

ellipsoidRef = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'ellipsoidRef'), EllipsoidPropertyType, documentation='', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 43, 1))
_Namespace_gml.addCategoryObject('elementBinding', ellipsoidRef.name().localName(), ellipsoidRef)

primeMeridianRef = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'primeMeridianRef'), PrimeMeridianPropertyType, documentation='', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 48, 1))
_Namespace_gml.addCategoryObject('elementBinding', primeMeridianRef.name().localName(), primeMeridianRef)

engineeringDatumRef = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'engineeringDatumRef'), EngineeringDatumPropertyType, documentation='', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 53, 1))
_Namespace_gml.addCategoryObject('elementBinding', engineeringDatumRef.name().localName(), engineeringDatumRef)

imageDatumRef = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'imageDatumRef'), ImageDatumPropertyType, documentation='', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 58, 1))
_Namespace_gml.addCategoryObject('elementBinding', imageDatumRef.name().localName(), imageDatumRef)

verticalDatumRef = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'verticalDatumRef'), VerticalDatumPropertyType, documentation='', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 63, 1))
_Namespace_gml.addCategoryObject('elementBinding', verticalDatumRef.name().localName(), verticalDatumRef)

temporalDatumRef = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'temporalDatumRef'), TemporalDatumPropertyType, documentation='', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 68, 1))
_Namespace_gml.addCategoryObject('elementBinding', temporalDatumRef.name().localName(), temporalDatumRef)

coordinateOperationRef = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'coordinateOperationRef'), CoordinateOperationPropertyType, documentation='', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 73, 1))
_Namespace_gml.addCategoryObject('elementBinding', coordinateOperationRef.name().localName(), coordinateOperationRef)

singleOperationRef = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'singleOperationRef'), SingleOperationPropertyType, documentation='', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 78, 1))
_Namespace_gml.addCategoryObject('elementBinding', singleOperationRef.name().localName(), singleOperationRef)

operationRef = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'operationRef'), OperationPropertyType, documentation='', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 97, 1))
_Namespace_gml.addCategoryObject('elementBinding', operationRef.name().localName(), operationRef)

generalConversionRef = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'generalConversionRef'), GeneralConversionPropertyType, documentation='', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 102, 1))
_Namespace_gml.addCategoryObject('elementBinding', generalConversionRef.name().localName(), generalConversionRef)

generalTransformationRef = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'generalTransformationRef'), GeneralTransformationPropertyType, documentation='', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 107, 1))
_Namespace_gml.addCategoryObject('elementBinding', generalTransformationRef.name().localName(), generalTransformationRef)

usesSingleOperation = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'usesSingleOperation'), CoordinateOperationPropertyType, documentation='', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 112, 1))
_Namespace_gml.addCategoryObject('elementBinding', usesSingleOperation.name().localName(), usesSingleOperation)

concatenatedOperationRef = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'concatenatedOperationRef'), ConcatenatedOperationPropertyType, documentation='', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 117, 1))
_Namespace_gml.addCategoryObject('elementBinding', concatenatedOperationRef.name().localName(), concatenatedOperationRef)

usesOperation = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'usesOperation'), CoordinateOperationPropertyType, documentation='', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 122, 1))
_Namespace_gml.addCategoryObject('elementBinding', usesOperation.name().localName(), usesOperation)

passThroughOperationRef = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'passThroughOperationRef'), PassThroughOperationPropertyType, documentation='', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 127, 1))
_Namespace_gml.addCategoryObject('elementBinding', passThroughOperationRef.name().localName(), passThroughOperationRef)

usesMethod = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'usesMethod'), OperationMethodPropertyType, documentation='', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 132, 1))
_Namespace_gml.addCategoryObject('elementBinding', usesMethod.name().localName(), usesMethod)

conversionRef = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'conversionRef'), ConversionPropertyType, documentation='', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 142, 1))
_Namespace_gml.addCategoryObject('elementBinding', conversionRef.name().localName(), conversionRef)

transformationRef = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'transformationRef'), TransformationPropertyType, documentation='', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 147, 1))
_Namespace_gml.addCategoryObject('elementBinding', transformationRef.name().localName(), transformationRef)

valueOfParameter = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'valueOfParameter'), OperationParameterPropertyType, documentation='', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 157, 1))
_Namespace_gml.addCategoryObject('elementBinding', valueOfParameter.name().localName(), valueOfParameter)

valuesOfGroup = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'valuesOfGroup'), OperationParameterGroupPropertyType, documentation='', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 167, 1))
_Namespace_gml.addCategoryObject('elementBinding', valuesOfGroup.name().localName(), valuesOfGroup)

usesParameter = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'usesParameter'), AbstractGeneralOperationParameterPropertyType, documentation='', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 177, 1))
_Namespace_gml.addCategoryObject('elementBinding', usesParameter.name().localName(), usesParameter)

operationMethodRef = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'operationMethodRef'), OperationMethodPropertyType, documentation='', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 182, 1))
_Namespace_gml.addCategoryObject('elementBinding', operationMethodRef.name().localName(), operationMethodRef)

abstractGeneralOperationParameterRef = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'abstractGeneralOperationParameterRef'), AbstractGeneralOperationParameterPropertyType, documentation='', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 187, 1))
_Namespace_gml.addCategoryObject('elementBinding', abstractGeneralOperationParameterRef.name().localName(), abstractGeneralOperationParameterRef)

operationParameterRef = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'operationParameterRef'), OperationParameterPropertyType, documentation='', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 192, 1))
_Namespace_gml.addCategoryObject('elementBinding', operationParameterRef.name().localName(), operationParameterRef)

includesParameter = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'includesParameter'), AbstractGeneralOperationParameterPropertyType, documentation='', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 197, 1))
_Namespace_gml.addCategoryObject('elementBinding', includesParameter.name().localName(), includesParameter)

operationParameterGroupRef = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'operationParameterGroupRef'), OperationParameterPropertyType, documentation='', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 202, 1))
_Namespace_gml.addCategoryObject('elementBinding', operationParameterGroupRef.name().localName(), operationParameterGroupRef)

referenceSystemRef = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'referenceSystemRef'), CRSPropertyType, documentation='', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 207, 1))
_Namespace_gml.addCategoryObject('elementBinding', referenceSystemRef.name().localName(), referenceSystemRef)

crsRef = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'crsRef'), CRSPropertyType, documentation='', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 212, 1))
_Namespace_gml.addCategoryObject('elementBinding', crsRef.name().localName(), crsRef)

coordinateSystemAxisRef = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'coordinateSystemAxisRef'), CoordinateSystemAxisPropertyType, documentation='', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 217, 1))
_Namespace_gml.addCategoryObject('elementBinding', coordinateSystemAxisRef.name().localName(), coordinateSystemAxisRef)

usesAxis = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'usesAxis'), CoordinateSystemAxisPropertyType, documentation='', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 222, 1))
_Namespace_gml.addCategoryObject('elementBinding', usesAxis.name().localName(), usesAxis)

coordinateSystemRef = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'coordinateSystemRef'), CoordinateSystemPropertyType, documentation='', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 227, 1))
_Namespace_gml.addCategoryObject('elementBinding', coordinateSystemRef.name().localName(), coordinateSystemRef)

ellipsoidalCSRef = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'ellipsoidalCSRef'), EllipsoidalCSPropertyType, documentation='', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 232, 1))
_Namespace_gml.addCategoryObject('elementBinding', ellipsoidalCSRef.name().localName(), ellipsoidalCSRef)

cartesianCSRef = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'cartesianCSRef'), CartesianCSPropertyType, documentation='', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 237, 1))
_Namespace_gml.addCategoryObject('elementBinding', cartesianCSRef.name().localName(), cartesianCSRef)

verticalCSRef = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'verticalCSRef'), VerticalCSPropertyType, documentation='', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 242, 1))
_Namespace_gml.addCategoryObject('elementBinding', verticalCSRef.name().localName(), verticalCSRef)

temporalCSRef = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'temporalCSRef'), TemporalCSPropertyType, documentation='', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 269, 1))
_Namespace_gml.addCategoryObject('elementBinding', temporalCSRef.name().localName(), temporalCSRef)

linearCSRef = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'linearCSRef'), LinearCSPropertyType, documentation='', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 274, 1))
_Namespace_gml.addCategoryObject('elementBinding', linearCSRef.name().localName(), linearCSRef)

userDefinedCSRef = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'userDefinedCSRef'), UserDefinedCSPropertyType, documentation='', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 279, 1))
_Namespace_gml.addCategoryObject('elementBinding', userDefinedCSRef.name().localName(), userDefinedCSRef)

sphericalCSRef = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'sphericalCSRef'), SphericalCSPropertyType, documentation='', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 284, 1))
_Namespace_gml.addCategoryObject('elementBinding', sphericalCSRef.name().localName(), sphericalCSRef)

polarCSRef = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'polarCSRef'), PolarCSPropertyType, documentation='', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 289, 1))
_Namespace_gml.addCategoryObject('elementBinding', polarCSRef.name().localName(), polarCSRef)

cylindricalCSRef = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'cylindricalCSRef'), CylindricalCSPropertyType, documentation='', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 294, 1))
_Namespace_gml.addCategoryObject('elementBinding', cylindricalCSRef.name().localName(), cylindricalCSRef)

obliqueCartesianCSRef = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'obliqueCartesianCSRef'), ObliqueCartesianCSPropertyType, documentation='', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 321, 1))
_Namespace_gml.addCategoryObject('elementBinding', obliqueCartesianCSRef.name().localName(), obliqueCartesianCSRef)

singleCRSRef = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'singleCRSRef'), SingleCRSPropertyType, documentation='', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 326, 1))
_Namespace_gml.addCategoryObject('elementBinding', singleCRSRef.name().localName(), singleCRSRef)

definedByConversion = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'definedByConversion'), GeneralConversionPropertyType, documentation='', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 331, 1))
_Namespace_gml.addCategoryObject('elementBinding', definedByConversion.name().localName(), definedByConversion)

includesSingleCRS = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'includesSingleCRS'), SingleCRSPropertyType, documentation='', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 336, 1))
_Namespace_gml.addCategoryObject('elementBinding', includesSingleCRS.name().localName(), includesSingleCRS)

compoundCRSRef = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'compoundCRSRef'), CompoundCRSPropertyType, documentation='', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 341, 1))
_Namespace_gml.addCategoryObject('elementBinding', compoundCRSRef.name().localName(), compoundCRSRef)

usesEllipsoidalCS = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'usesEllipsoidalCS'), EllipsoidalCSPropertyType, documentation='', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 346, 1))
_Namespace_gml.addCategoryObject('elementBinding', usesEllipsoidalCS.name().localName(), usesEllipsoidalCS)

usesCartesianCS = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'usesCartesianCS'), CartesianCSPropertyType, documentation='', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 351, 1))
_Namespace_gml.addCategoryObject('elementBinding', usesCartesianCS.name().localName(), usesCartesianCS)

usesSphericalCS = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'usesSphericalCS'), SphericalCSPropertyType, documentation='', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 356, 1))
_Namespace_gml.addCategoryObject('elementBinding', usesSphericalCS.name().localName(), usesSphericalCS)

usesGeodeticDatum = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'usesGeodeticDatum'), GeodeticDatumPropertyType, documentation='', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 361, 1))
_Namespace_gml.addCategoryObject('elementBinding', usesGeodeticDatum.name().localName(), usesGeodeticDatum)

usesVerticalCS = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'usesVerticalCS'), VerticalCSPropertyType, documentation='', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 366, 1))
_Namespace_gml.addCategoryObject('elementBinding', usesVerticalCS.name().localName(), usesVerticalCS)

usesVerticalDatum = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'usesVerticalDatum'), VerticalDatumPropertyType, documentation='', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 371, 1))
_Namespace_gml.addCategoryObject('elementBinding', usesVerticalDatum.name().localName(), usesVerticalDatum)

verticalCRSRef = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'verticalCRSRef'), VerticalCRSPropertyType, documentation='', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 376, 1))
_Namespace_gml.addCategoryObject('elementBinding', verticalCRSRef.name().localName(), verticalCRSRef)

baseGeographicCRS = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'baseGeographicCRS'), GeographicCRSPropertyType, documentation='', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 381, 1))
_Namespace_gml.addCategoryObject('elementBinding', baseGeographicCRS.name().localName(), baseGeographicCRS)

projectedCRSRef = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'projectedCRSRef'), ProjectedCRSPropertyType, documentation='', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 386, 1))
_Namespace_gml.addCategoryObject('elementBinding', projectedCRSRef.name().localName(), projectedCRSRef)

usesCS = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'usesCS'), CoordinateSystemPropertyType, documentation='', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 391, 1))
_Namespace_gml.addCategoryObject('elementBinding', usesCS.name().localName(), usesCS)

derivedCRSRef = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'derivedCRSRef'), DerivedCRSPropertyType, documentation='', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 396, 1))
_Namespace_gml.addCategoryObject('elementBinding', derivedCRSRef.name().localName(), derivedCRSRef)

usesEngineeringDatum = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'usesEngineeringDatum'), EngineeringDatumPropertyType, documentation='', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 401, 1))
_Namespace_gml.addCategoryObject('elementBinding', usesEngineeringDatum.name().localName(), usesEngineeringDatum)

engineeringCRSRef = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'engineeringCRSRef'), EngineeringCRSPropertyType, documentation='', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 406, 1))
_Namespace_gml.addCategoryObject('elementBinding', engineeringCRSRef.name().localName(), engineeringCRSRef)

usesAffineCS = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'usesAffineCS'), AffineCSPropertyType, documentation='', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 411, 1))
_Namespace_gml.addCategoryObject('elementBinding', usesAffineCS.name().localName(), usesAffineCS)

usesImageDatum = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'usesImageDatum'), ImageDatumPropertyType, documentation='', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 416, 1))
_Namespace_gml.addCategoryObject('elementBinding', usesImageDatum.name().localName(), usesImageDatum)

usesObliqueCartesianCS = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'usesObliqueCartesianCS'), ObliqueCartesianCSPropertyType, documentation='', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 421, 1))
_Namespace_gml.addCategoryObject('elementBinding', usesObliqueCartesianCS.name().localName(), usesObliqueCartesianCS)

imageCRSRef = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'imageCRSRef'), ImageCRSPropertyType, documentation='', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 426, 1))
_Namespace_gml.addCategoryObject('elementBinding', imageCRSRef.name().localName(), imageCRSRef)

usesTimeCS = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'usesTimeCS'), TimeCSPropertyType, documentation='', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 431, 1))
_Namespace_gml.addCategoryObject('elementBinding', usesTimeCS.name().localName(), usesTimeCS)

usesTemporalCS = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'usesTemporalCS'), TemporalCSPropertyType, documentation='', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 436, 1))
_Namespace_gml.addCategoryObject('elementBinding', usesTemporalCS.name().localName(), usesTemporalCS)

usesTemporalDatum = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'usesTemporalDatum'), TemporalDatumPropertyType, documentation='', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 441, 1))
_Namespace_gml.addCategoryObject('elementBinding', usesTemporalDatum.name().localName(), usesTemporalDatum)

temporalCRSRef = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'temporalCRSRef'), TemporalCRSPropertyType, documentation='', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 446, 1))
_Namespace_gml.addCategoryObject('elementBinding', temporalCRSRef.name().localName(), temporalCRSRef)

geographicCRSRef = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'geographicCRSRef'), GeographicCRSPropertyType, documentation='', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 478, 1))
_Namespace_gml.addCategoryObject('elementBinding', geographicCRSRef.name().localName(), geographicCRSRef)

geocentricCRSRef = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'geocentricCRSRef'), GeocentricCRSPropertyType, documentation='', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 513, 1))
_Namespace_gml.addCategoryObject('elementBinding', geocentricCRSRef.name().localName(), geocentricCRSRef)

member = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'member'), AssociationRoleType, documentation='', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 643, 1))
_Namespace_gml.addCategoryObject('elementBinding', member.name().localName(), member)

metaDataProperty = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'metaDataProperty'), MetaDataPropertyType, documentation='', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 672, 1))
_Namespace_gml.addCategoryObject('elementBinding', metaDataProperty.name().localName(), metaDataProperty)

pointRep = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'pointRep'), PointPropertyType, documentation='', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 756, 1))
_Namespace_gml.addCategoryObject('elementBinding', pointRep.name().localName(), pointRep)

location = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'location'), LocationPropertyType, documentation='', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 761, 1))
_Namespace_gml.addCategoryObject('elementBinding', location.name().localName(), location)

LocationString = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'LocationString'), StringOrRefType, documentation='', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 780, 1))
_Namespace_gml.addCategoryObject('elementBinding', LocationString.name().localName(), LocationString)

featureMember = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'featureMember'), FeaturePropertyType, documentation='', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 805, 1))
_Namespace_gml.addCategoryObject('elementBinding', featureMember.name().localName(), featureMember)

featureProperty = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'featureProperty'), FeaturePropertyType, documentation='', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 810, 1))
_Namespace_gml.addCategoryObject('elementBinding', featureProperty.name().localName(), featureProperty)

AbstractFeatureCollection = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractFeatureCollection'), AbstractFeatureCollectionType, abstract=pyxb.binding.datatypes.boolean(1), documentation='', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 855, 1))
_Namespace_gml.addCategoryObject('elementBinding', AbstractFeatureCollection.name().localName(), AbstractFeatureCollection)

definitionMember = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'definitionMember'), DictionaryEntryType, documentation='', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 883, 1))
_Namespace_gml.addCategoryObject('elementBinding', definitionMember.name().localName(), definitionMember)

definitionRef = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'definitionRef'), ReferenceType, documentation='', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 918, 1))
_Namespace_gml.addCategoryObject('elementBinding', definitionRef.name().localName(), definitionRef)

MappingRule = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'MappingRule'), StringOrRefType, documentation='', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 923, 1))
_Namespace_gml.addCategoryObject('elementBinding', MappingRule.name().localName(), MappingRule)

centerOf = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'centerOf'), PointPropertyType, documentation='', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 939, 1))
_Namespace_gml.addCategoryObject('elementBinding', centerOf.name().localName(), centerOf)

position = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'position'), PointPropertyType, documentation='', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 944, 1))
_Namespace_gml.addCategoryObject('elementBinding', position.name().localName(), position)

extentOf = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'extentOf'), SurfacePropertyType, documentation='', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 949, 1))
_Namespace_gml.addCategoryObject('elementBinding', extentOf.name().localName(), extentOf)

edgeOf = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'edgeOf'), CurvePropertyType, documentation='', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 954, 1))
_Namespace_gml.addCategoryObject('elementBinding', edgeOf.name().localName(), edgeOf)

centerLineOf = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'centerLineOf'), CurvePropertyType, documentation='', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 959, 1))
_Namespace_gml.addCategoryObject('elementBinding', centerLineOf.name().localName(), centerLineOf)

multiLocation = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'multiLocation'), MultiPointPropertyType, documentation='', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 964, 1))
_Namespace_gml.addCategoryObject('elementBinding', multiLocation.name().localName(), multiLocation)

multiCenterOf = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'multiCenterOf'), MultiPointPropertyType, documentation='', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 969, 1))
_Namespace_gml.addCategoryObject('elementBinding', multiCenterOf.name().localName(), multiCenterOf)

multiPosition = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'multiPosition'), MultiPointPropertyType, documentation='', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 974, 1))
_Namespace_gml.addCategoryObject('elementBinding', multiPosition.name().localName(), multiPosition)

multiCenterLineOf = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'multiCenterLineOf'), MultiCurvePropertyType, documentation='', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 979, 1))
_Namespace_gml.addCategoryObject('elementBinding', multiCenterLineOf.name().localName(), multiCenterLineOf)

multiEdgeOf = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'multiEdgeOf'), MultiCurvePropertyType, documentation='', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 984, 1))
_Namespace_gml.addCategoryObject('elementBinding', multiEdgeOf.name().localName(), multiEdgeOf)

multiCoverage = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'multiCoverage'), MultiSurfacePropertyType, documentation='', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 989, 1))
_Namespace_gml.addCategoryObject('elementBinding', multiCoverage.name().localName(), multiCoverage)

multiExtentOf = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'multiExtentOf'), MultiSurfacePropertyType, documentation='', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 994, 1))
_Namespace_gml.addCategoryObject('elementBinding', multiExtentOf.name().localName(), multiExtentOf)

multiPointDomain = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'multiPointDomain'), DomainSetType, documentation='', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 1009, 1))
_Namespace_gml.addCategoryObject('elementBinding', multiPointDomain.name().localName(), multiPointDomain)

multiCurveDomain = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'multiCurveDomain'), DomainSetType, documentation='', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 1014, 1))
_Namespace_gml.addCategoryObject('elementBinding', multiCurveDomain.name().localName(), multiCurveDomain)

multiSurfaceDomain = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'multiSurfaceDomain'), DomainSetType, documentation='', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 1019, 1))
_Namespace_gml.addCategoryObject('elementBinding', multiSurfaceDomain.name().localName(), multiSurfaceDomain)

multiSolidDomain = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'multiSolidDomain'), DomainSetType, documentation='', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 1024, 1))
_Namespace_gml.addCategoryObject('elementBinding', multiSolidDomain.name().localName(), multiSolidDomain)

gridDomain = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'gridDomain'), DomainSetType, documentation='', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 1029, 1))
_Namespace_gml.addCategoryObject('elementBinding', gridDomain.name().localName(), gridDomain)

rectifiedGridDomain = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'rectifiedGridDomain'), DomainSetType, documentation='', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 1034, 1))
_Namespace_gml.addCategoryObject('elementBinding', rectifiedGridDomain.name().localName(), rectifiedGridDomain)

generalOperationParameter = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'generalOperationParameter'), AbstractGeneralOperationParameterPropertyType, documentation='', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 1039, 1))
_Namespace_gml.addCategoryObject('elementBinding', generalOperationParameter.name().localName(), generalOperationParameter)

MovingObjectStatus = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'MovingObjectStatus'), MovingObjectStatusType, documentation='', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 1044, 1))
_Namespace_gml.addCategoryObject('elementBinding', MovingObjectStatus.name().localName(), MovingObjectStatus)

status = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'status'), StringOrRefType, documentation='', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 1073, 1))
_Namespace_gml.addCategoryObject('elementBinding', status.name().localName(), status)

statusReference = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'statusReference'), ReferenceType, documentation='', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 1078, 1))
_Namespace_gml.addCategoryObject('elementBinding', statusReference.name().localName(), statusReference)

topoComplexProperty = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'topoComplexProperty'), TopoComplexPropertyType, documentation='', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 1083, 2))
_Namespace_gml.addCategoryObject('elementBinding', topoComplexProperty.name().localName(), topoComplexProperty)

multiPointProperty = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'multiPointProperty'), MultiPointPropertyType, documentation='', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 1088, 1))
_Namespace_gml.addCategoryObject('elementBinding', multiPointProperty.name().localName(), multiPointProperty)

multiCurveProperty = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'multiCurveProperty'), MultiCurvePropertyType, documentation='', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 1093, 1))
_Namespace_gml.addCategoryObject('elementBinding', multiCurveProperty.name().localName(), multiCurveProperty)

multiSurfaceProperty = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'multiSurfaceProperty'), MultiSurfacePropertyType, documentation='', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 1098, 1))
_Namespace_gml.addCategoryObject('elementBinding', multiSurfaceProperty.name().localName(), multiSurfaceProperty)

multiSolidProperty = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'multiSolidProperty'), MultiSolidPropertyType, documentation='', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 1103, 1))
_Namespace_gml.addCategoryObject('elementBinding', multiSolidProperty.name().localName(), multiSolidProperty)

multiGeometryProperty = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'multiGeometryProperty'), MultiGeometryPropertyType, documentation='', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 1108, 1))
_Namespace_gml.addCategoryObject('elementBinding', multiGeometryProperty.name().localName(), multiGeometryProperty)

Definition = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'Definition'), DefinitionType, documentation='The basic gml:Definition element specifies a definition, which can be included in or referenced by a dictionary. \nThe content model for a generic definition is a derivation from gml:AbstractGMLType.  \nThe gml:description property element shall hold the definition if this can be captured in a simple text string, or the gml:descriptionReference property element may carry a link to a description elsewhere.\nThe gml:identifier element shall provide one identifier identifying this definition. The identifier shall be unique within the dictionaries using this definition. \nThe gml:name elements shall provide zero or more terms and synonyms for which this is the definition.\nThe gml:remarks element shall be used to hold additional textual information that is not conceptually part of the definition but is useful in understanding the definition.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 21, 1))
_Namespace_gml.addCategoryObject('elementBinding', Definition.name().localName(), Definition)

dictionaryEntry = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'dictionaryEntry'), DictionaryEntryType, documentation='This property element contains or refers to the definitions which are members of a dictionary. \nThe content model follows the standard GML property pattern, so a gml:dictionaryEntry may either contain or refer to a single gml:Definition. Since gml:Dictionary is substitutable for gml:Definition, the content of an entry may itself be a lower level dictionary. \nNote that if the value is provided by reference, this definition does not carry a handle (gml:id) in this context, so does not allow external references to this specific definition in this context.  When used in this way the referenced definition will usually be in a dictionary in the same XML document.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 73, 1))
_Namespace_gml.addCategoryObject('elementBinding', dictionaryEntry.name().localName(), dictionaryEntry)

direction = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'direction'), DirectionPropertyType, documentation='The property gml:direction is intended as a pre-defined property expressing a direction to be assigned to features defined in a GML application schema.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/direction.xsd', 15, 1))
_Namespace_gml.addCategoryObject('elementBinding', direction.name().localName(), direction)

dataSource = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'dataSource'), StringOrRefType, documentation='Evidence is represented by a simple gml:dataSource or gml:dataSourceReference property that indicates the source of the temporal data. The remote link attributes of the gml:dataSource element have been deprecated along with its current type.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dynamicFeature.xsd', 17, 1))
_Namespace_gml.addCategoryObject('elementBinding', dataSource.name().localName(), dataSource)

dataSourceReference = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'dataSourceReference'), ReferenceType, documentation='Evidence is represented by a simple gml:dataSource or gml:dataSourceReference property that indicates the source of the temporal data.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dynamicFeature.xsd', 22, 1))
_Namespace_gml.addCategoryObject('elementBinding', dataSourceReference.name().localName(), dataSourceReference)

DynamicFeature = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'DynamicFeature'), DynamicFeatureType, documentation="States are captured by time-stamped instances of a feature. The content model extends the standard gml:AbstractFeatureType with the gml:dynamicProperties model group.\nEach time-stamped instance represents a 'snapshot' of a feature. The dynamic feature classes will normally be extended to suit particular applications.  A dynamic feature bears either a time stamp or a history.", location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dynamicFeature.xsd', 38, 1))
_Namespace_gml.addCategoryObject('elementBinding', DynamicFeature.name().localName(), DynamicFeature)

dynamicMembers = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'dynamicMembers'), DynamicFeatureMemberType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dynamicFeature.xsd', 67, 1))
_Namespace_gml.addCategoryObject('elementBinding', dynamicMembers.name().localName(), dynamicMembers)

boundedBy = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'boundedBy'), BoundingShapeType, nillable=pyxb.binding.datatypes.boolean(1), documentation='This property describes the minimum bounding box or rectangle that encloses the entire feature.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/feature.xsd', 45, 1))
_Namespace_gml.addCategoryObject('elementBinding', boundedBy.name().localName(), boundedBy)

EnvelopeWithTimePeriod = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'EnvelopeWithTimePeriod'), EnvelopeWithTimePeriodType, documentation='gml:EnvelopeWithTimePeriod is provided for envelopes that include a temporal extent. It adds two time position properties, gml:beginPosition and gml:endPosition, which describe the extent of a time-envelope.  \nSince gml:EnvelopeWithTimePeriod is assigned to the substitution group headed by gml:Envelope, it may be used whenever gml:Envelope is valid.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/feature.xsd', 59, 1))
_Namespace_gml.addCategoryObject('elementBinding', EnvelopeWithTimePeriod.name().localName(), EnvelopeWithTimePeriod)

locationReference = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'locationReference'), ReferenceType, documentation='The gml:locationReference property element is a convenience property where the text value referenced by the xlink:href attribute describes the location of the feature.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/feature.xsd', 81, 1))
_Namespace_gml.addCategoryObject('elementBinding', locationReference.name().localName(), locationReference)

AbstractGeometricAggregate = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractGeometricAggregate'), AbstractGeometricAggregateType, abstract=pyxb.binding.datatypes.boolean(1), documentation='gml:AbstractGeometricAggregate is the abstract head of the substitution group for all geometric aggregates.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryAggregates.xsd', 22, 1))
_Namespace_gml.addCategoryObject('elementBinding', AbstractGeometricAggregate.name().localName(), AbstractGeometricAggregate)

geometryMember = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'geometryMember'), GeometryPropertyType, documentation='This property element either references a geometry element via the XLink-attributes or contains the geometry element.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryAggregates.xsd', 43, 1))
_Namespace_gml.addCategoryObject('elementBinding', geometryMember.name().localName(), geometryMember)

pointMember = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'pointMember'), PointPropertyType, documentation='This property element either references a Point via the XLink-attributes or contains the Point element.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryAggregates.xsd', 79, 1))
_Namespace_gml.addCategoryObject('elementBinding', pointMember.name().localName(), pointMember)

solidMember = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'solidMember'), SolidPropertyType, documentation='This property element either references a solid via the XLink-attributes or contains the solid element. A solid element is any element, which is substitutable for gml:AbstractSolid.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryAggregates.xsd', 177, 1))
_Namespace_gml.addCategoryObject('elementBinding', solidMember.name().localName(), solidMember)

vector = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'vector'), VectorType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic0d1d.xsd', 132, 1))
_Namespace_gml.addCategoryObject('elementBinding', vector.name().localName(), vector)

AbstractGeometricPrimitive = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractGeometricPrimitive'), AbstractGeometricPrimitiveType, abstract=pyxb.binding.datatypes.boolean(1), documentation='The AbstractGeometricPrimitive element is the abstract head of the substitution group for all (pre- and user-defined) geometric primitives.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic0d1d.xsd', 162, 1))
_Namespace_gml.addCategoryObject('elementBinding', AbstractGeometricPrimitive.name().localName(), AbstractGeometricPrimitive)

pointProperty = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'pointProperty'), PointPropertyType, documentation='This property element either references a point via the XLink-attributes or contains the point element. pointProperty is the predefined property which may be used by GML Application Schemas whenever a GML feature has a property with a value that is substitutable for Point.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic0d1d.xsd', 204, 1))
_Namespace_gml.addCategoryObject('elementBinding', pointProperty.name().localName(), pointProperty)

curveProperty = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'curveProperty'), CurvePropertyType, documentation='This property element either references a curve via the XLink-attributes or contains the curve element. curveProperty is the predefined property which may be used by GML Application Schemas whenever a GML feature has a property with a value that is substitutable for AbstractCurve.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic0d1d.xsd', 241, 1))
_Namespace_gml.addCategoryObject('elementBinding', curveProperty.name().localName(), curveProperty)

surfaceProperty = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'surfaceProperty'), SurfacePropertyType, documentation='This property element either references a surface via the XLink-attributes or contains the surface element. surfaceProperty is the predefined property which may be used by GML Application Schemas whenever a GML feature has a property with a value that is substitutable for AbstractSurface.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic2d.xsd', 37, 1))
_Namespace_gml.addCategoryObject('elementBinding', surfaceProperty.name().localName(), surfaceProperty)

GeometricComplex = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'GeometricComplex'), GeometricComplexType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryComplexes.xsd', 28, 1))
_Namespace_gml.addCategoryObject('elementBinding', GeometricComplex.name().localName(), GeometricComplex)

baseCurve = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'baseCurve'), CurvePropertyType, documentation='The property baseCurve references or contains the base curve, i.e. it either references the base curve via the XLink-attributes or contains the curve element. A curve element is any element which is substitutable for AbstractCurve. The base curve has positive orientation.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 42, 1))
_Namespace_gml.addCategoryObject('elementBinding', baseCurve.name().localName(), baseCurve)

Arc = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'Arc'), ArcType, documentation='An Arc is an arc string with only one arc unit, i.e. three control points including the start and end point. As arc is an arc string consisting of a single arc, the attribute "numArc" is fixed to "1".', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 163, 1))
_Namespace_gml.addCategoryObject('elementBinding', Arc.name().localName(), Arc)

ArcByBulge = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'ArcByBulge'), ArcByBulgeType, documentation='An ArcByBulge is an arc string with only one arc unit, i.e. two control points, one bulge and one normal vector.\nAs arc is an arc string consisting of a single arc, the attribute "numArc" is fixed to "1".', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 227, 1))
_Namespace_gml.addCategoryObject('elementBinding', ArcByBulge.name().localName(), ArcByBulge)

CircleByCenterPoint = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'CircleByCenterPoint'), CircleByCenterPointType, documentation='A gml:CircleByCenterPoint is an gml:ArcByCenterPoint with identical start and end angle to form a full circle. Again, this representation can be used only in 2D.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 284, 1))
_Namespace_gml.addCategoryObject('elementBinding', CircleByCenterPoint.name().localName(), CircleByCenterPoint)

Bezier = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'Bezier'), BezierType, documentation='Bezier curves are polynomial splines that use Bezier or Bernstein polynomials for interpolation purposes. It is a special case of the B-Spline curve with two knots.\ndegree shall be the degree of the polynomial used for interpolation in this spline.\nknot shall be the sequence of distinct knots used to define the spline basis functions.\ninterpolation is fixed as "polynomialSpline".\nisPolynomial is fixed as "true".\nknotType is not relevant for Bezier curve segments.\n', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 405, 1))
_Namespace_gml.addCategoryObject('elementBinding', Bezier.name().localName(), Bezier)

Geodesic = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'Geodesic'), GeodesicType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 497, 1))
_Namespace_gml.addCategoryObject('elementBinding', Geodesic.name().localName(), Geodesic)

baseSurface = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'baseSurface'), SurfacePropertyType, documentation='The property baseSurface references or contains the base surface. The property baseSurface either references the base surface via the XLink-attributes or contains the surface element. A surface element is any element which is substitutable for gml:AbstractSurface. The base surface has positive orientation.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 523, 1))
_Namespace_gml.addCategoryObject('elementBinding', baseSurface.name().localName(), baseSurface)

curveMember = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'curveMember'), CurvePropertyType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 639, 1))
_Namespace_gml.addCategoryObject('elementBinding', curveMember.name().localName(), curveMember)

AbstractGriddedSurface = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractGriddedSurface'), AbstractGriddedSurfaceType, abstract=pyxb.binding.datatypes.boolean(1), documentation='if provided, rows gives the number of rows, columns the number of columns in the parameter grid. The parameter grid is represented by an instance of the gml:PointGrid group.\nThe element provides a substitution group head for the surface patches based on a grid. All derived subtypes shall conform to the constraints specified in ISO 19107:2003, 6.4.41.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 690, 1))
_Namespace_gml.addCategoryObject('elementBinding', AbstractGriddedSurface.name().localName(), AbstractGriddedSurface)

solidProperty = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'solidProperty'), SolidPropertyType, documentation='This property element either references a solid via the XLink-attributes or contains the solid element. solidProperty is the predefined property which may be used by GML Application Schemas whenever a GML feature has a property with a value that is substitutable for AbstractSolid.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 790, 1))
_Namespace_gml.addCategoryObject('elementBinding', solidProperty.name().localName(), solidProperty)

surfaceMember = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'surfaceMember'), SurfacePropertyType, documentation='This property element either references a surface via the XLink-attributes or contains the surface element. A surface element is any element, which is substitutable for gml:AbstractSurface.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 837, 1))
_Namespace_gml.addCategoryObject('elementBinding', surfaceMember.name().localName(), surfaceMember)

abstractAssociationRole = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'abstractAssociationRole'), AssociationRoleType, abstract=pyxb.binding.datatypes.boolean(1), documentation='Applying this pattern shall restrict the multiplicity of objects in a property element using this content model to exactly one. An instance of this type shall contain an element representing an object, or serve as a pointer to a remote object.\nApplying the pattern to define an application schema specific property type allows to restrict\n-\tthe inline object to specified object types, \n-\tthe encoding to "by-reference only" (see 7.2.3.7),\n-\tthe encoding to "inline only" (see 7.2.3.8).', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 58, 1))
_Namespace_gml.addCategoryObject('elementBinding', abstractAssociationRole.name().localName(), abstractAssociationRole)

abstractStrictAssociationRole = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'abstractStrictAssociationRole'), AssociationRoleType, abstract=pyxb.binding.datatypes.boolean(1), documentation='This element shows how an element \n\tdeclaration may include a Schematron constraint to limit the property to act \n\tin either inline or by-reference mode, but not both.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 81, 1))
_Namespace_gml.addCategoryObject('elementBinding', abstractStrictAssociationRole.name().localName(), abstractStrictAssociationRole)

abstractReference = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'abstractReference'), ReferenceType, abstract=pyxb.binding.datatypes.boolean(1), documentation='gml:abstractReference may be used as the head of a subtitution group of more specific elements providing a value by-reference.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 88, 1))
_Namespace_gml.addCategoryObject('elementBinding', abstractReference.name().localName(), abstractReference)

description = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'description'), StringOrRefType, documentation='The value of this property is a text description of the object. gml:description uses gml:StringOrRefType as its content model, so it may contain a simple text string content, or carry a reference to an external description. The use of gml:description to reference an external description has been deprecated and replaced by the gml:descriptionReference property.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 117, 1))
_Namespace_gml.addCategoryObject('elementBinding', description.name().localName(), description)

descriptionReference = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'descriptionReference'), ReferenceType, documentation='The value of this property is a remote text description of the object. The xlink:href attribute of the gml:descriptionReference property references the external description.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 122, 1))
_Namespace_gml.addCategoryObject('elementBinding', descriptionReference.name().localName(), descriptionReference)

Grid = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'Grid'), GridType, documentation='The gml:Grid implicitly defines an unrectified grid, which is a network composed of two or more sets of curves in which the members of each set intersect the members of the other sets in an algorithmic way.  The region of interest within the grid is given in terms of its gml:limits, being the grid coordinates of  diagonally opposed corners of a rectangular region.  gml:axisLabels is provided with a list of labels of the axes of the grid (gml:axisName has been deprecated). gml:dimension specifies the dimension of the grid.  \nThe gml:limits element contains a single gml:GridEnvelope. The gml:low and gml:high property elements of the envelope are each integerLists, which are coordinate tuples, the coordinates being measured as offsets from the origin of the grid along each axis, of the diagonally opposing corners of a "rectangular" region of interest.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/grids.xsd', 16, 1))
_Namespace_gml.addCategoryObject('elementBinding', Grid.name().localName(), Grid)

measure = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'measure'), MeasureType, documentation='The value of a physical quantity, together with its unit.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/measures.xsd', 15, 1))
_Namespace_gml.addCategoryObject('elementBinding', measure.name().localName(), measure)

Observation = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'Observation'), ObservationType, documentation='The content model is a straightforward extension of gml:AbstractFeatureType; it automatically has the gml:identifier, gml:description, gml:descriptionReference, gml:name, and gml:boundedBy properties. \nThe gml:validTime element describes the time of the observation. Note that this may be a time instant or a time period.\nThe gml:using property contains or references a description of a sensor, instrument or procedure used for the observation.\nThe gml:target property contains or references the specimen, region or station which is the object of the observation. This property is particularly useful for remote observations, such as photographs, where a generic location property might apply to the location of the camera or the location of the field of view, and thus may be ambiguous.  \nThe gml:subject element is provided as a convenient synonym for gml:target. This is the term commonly used in phtotography.  \nThe gml:resultOf property indicates the result of the observation.  The value may be inline, or a reference to a value elsewhere.\n', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/observation.xsd', 18, 1))
_Namespace_gml.addCategoryObject('elementBinding', Observation.name().localName(), Observation)

using = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'using'), ProcedurePropertyType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/observation.xsd', 41, 1))
_Namespace_gml.addCategoryObject('elementBinding', using.name().localName(), using)

target = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'target'), TargetPropertyType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/observation.xsd', 49, 1))
_Namespace_gml.addCategoryObject('elementBinding', target.name().localName(), target)

subject = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'subject'), TargetPropertyType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/observation.xsd', 50, 1))
_Namespace_gml.addCategoryObject('elementBinding', subject.name().localName(), subject)

resultOf = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'resultOf'), ResultType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/observation.xsd', 59, 1))
_Namespace_gml.addCategoryObject('elementBinding', resultOf.name().localName(), resultOf)

domainOfValidity = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'domainOfValidity'), CTD_ANON_8, documentation='The gml:domainOfValidity property implements an association role to an EX_Extent object as encoded in ISO/TS 19139, either referencing or containing the definition of that extent.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/referenceSystems.xsd', 45, 1))
_Namespace_gml.addCategoryObject('elementBinding', domainOfValidity.name().localName(), domainOfValidity)

AbstractTimePrimitive = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractTimePrimitive'), AbstractTimePrimitiveType, abstract=pyxb.binding.datatypes.boolean(1), documentation='gml:AbstractTimePrimitive acts as the head of a substitution group for geometric and topological temporal primitives.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporal.xsd', 28, 1))
_Namespace_gml.addCategoryObject('elementBinding', AbstractTimePrimitive.name().localName(), AbstractTimePrimitive)

validTime = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'validTime'), TimePrimitivePropertyType, documentation='gml:validTime is a convenience property element.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporal.xsd', 52, 1))
_Namespace_gml.addCategoryObject('elementBinding', validTime.name().localName(), validTime)

AbstractTimeComplex = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractTimeComplex'), AbstractTimeComplexType, abstract=pyxb.binding.datatypes.boolean(1), documentation='gml:AbstractTimeComplex is an aggregation of temporal primitives and acts as the head of a substitution group for temporal complexes.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporal.xsd', 85, 1))
_Namespace_gml.addCategoryObject('elementBinding', AbstractTimeComplex.name().localName(), AbstractTimeComplex)

timeInterval = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'timeInterval'), TimeIntervalLengthType, documentation=' gml:timeInterval conforms to ISO 11404 which is based on floating point values for temporal length.\nISO 11404 syntax specifies the use of a positiveInteger together with appropriate values for radix and factor. The resolution of the time interval is to one radix ^(-factor) of the specified time unit.\nThe value of the unit is either selected from the units for time intervals from ISO 31-1:1992, or is another suitable unit.  The encoding is defined for GML in gml:TimeUnitType. The second component of this union type provides a method for indicating time units other than the six standard units given in the enumeration.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporal.xsd', 234, 1))
_Namespace_gml.addCategoryObject('elementBinding', timeInterval.name().localName(), timeInterval)

AbstractTopoPrimitive = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractTopoPrimitive'), AbstractTopoPrimitiveType, abstract=pyxb.binding.datatypes.boolean(1), documentation='gml:AbstractTopoPrimitive acts as the base type for all topological primitives. Topology primitives are the atomic (smallest possible) units of a topology complex. \nEach topology primitive may contain references to other topology primitives of codimension 2 or more (gml:isolated). Conversely, nodes may have faces as containers and nodes and edges may have solids as containers (gml:container).', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/topology.xsd', 31, 2))
_Namespace_gml.addCategoryObject('elementBinding', AbstractTopoPrimitive.name().localName(), AbstractTopoPrimitive)

directedNode = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'directedNode'), DirectedNodePropertyType, documentation='A gml:directedNode property element describes the boundary of topology edges and is used in the support of topological point features via the gml:TopoPoint expression, see below. The orientation attribute of type gml:SignType expresses the sense in which the included node is used: start ("-") or end ("+") node.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/topology.xsd', 91, 2))
_Namespace_gml.addCategoryObject('elementBinding', directedNode.name().localName(), directedNode)

directedEdge = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'directedEdge'), DirectedEdgePropertyType, documentation='A gml:directedEdge property element describes the boundary of topology faces, the coBoundary of topology nodes and is used in the support of topological line features via the gml:TopoCurve expression, see below. The orientation attribute of type gml:SignType expresses the sense in which the included edge is used, i.e. forward or reverse.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/topology.xsd', 126, 2))
_Namespace_gml.addCategoryObject('elementBinding', directedEdge.name().localName(), directedEdge)

directedFace = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'directedFace'), DirectedFacePropertyType, documentation='The gml:directedFace property element describes the boundary of topology solids, in the coBoundary of topology edges and is used in the support of surface features via the gml:TopoSurface expression, see below. The orientation attribute of type gml:SignType expresses the sense in which the included face is used i.e. inward or outward with respect to the surface normal in any geometric realisation.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/topology.xsd', 165, 2))
_Namespace_gml.addCategoryObject('elementBinding', directedFace.name().localName(), directedFace)

directedTopoSolid = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'directedTopoSolid'), DirectedTopoSolidPropertyType, documentation='The gml:directedSolid property element describes the coBoundary of topology faces and is used in the support of volume features via the gml:TopoVolume expression, see below. The orientation attribute of type gml:SignType expresses the sense in which the included solid appears in the face coboundary. In the context of a gml:TopoVolume the orientation attribute has no meaning.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/topology.xsd', 202, 2))
_Namespace_gml.addCategoryObject('elementBinding', directedTopoSolid.name().localName(), directedTopoSolid)

TopoPoint = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'TopoPoint'), TopoPointType, documentation='The intended use of gml:TopoPoint is to appear within a point feature to express the structural and possibly geometric relationships of this feature to other features via shared node definitions.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/topology.xsd', 224, 2))
_Namespace_gml.addCategoryObject('elementBinding', TopoPoint.name().localName(), TopoPoint)

TopoCurve = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'TopoCurve'), TopoCurveType, documentation='gml:TopoCurve represents a homogeneous topological expression, a sequence of directed edges, which if realised are isomorphic to a geometric curve primitive. The intended use of gml:TopoCurve is to appear within a line feature to express the structural and geometric relationships of this feature to other features via the shared edge definitions.\nIf provided, the aggregationType attribute shall have the value "sequence".', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/topology.xsd', 250, 2))
_Namespace_gml.addCategoryObject('elementBinding', TopoCurve.name().localName(), TopoCurve)

TopoSurface = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'TopoSurface'), TopoSurfaceType, documentation='gml:TopoSurface represents a homogeneous topological expression, a set of directed faces, which if realised are isomorphic to a geometric surface primitive. The intended use of gml:TopoSurface is to appear within a surface feature to express the structural and possibly geometric relationships of this surface feature to other features via the shared face definitions.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/topology.xsd', 277, 2))
_Namespace_gml.addCategoryObject('elementBinding', TopoSurface.name().localName(), TopoSurface)

TopoVolume = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'TopoVolume'), TopoVolumeType, documentation='gml:TopoVolume represents a homogeneous topological expression, a set of directed topologic solids, which if realised are isomorphic to a geometric solid primitive. The intended use of gml:TopoVolume is to appear within a solid feature to express the structural and geometric relationships of this solid feature to other features via the shared solid definitions.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/topology.xsd', 303, 2))
_Namespace_gml.addCategoryObject('elementBinding', TopoVolume.name().localName(), TopoVolume)

TopoComplex = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'TopoComplex'), TopoComplexType, documentation='gml:TopoComplex is a collection of topological primitives.\nEach complex holds a reference to its maximal complex (gml:maximalComplex) and optionally to sub- or super-complexes (gml:subComplex, gml:superComplex). \nA topology complex contains its primitive and sub-complex members.\n', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/topology.xsd', 334, 2))
_Namespace_gml.addCategoryObject('elementBinding', TopoComplex.name().localName(), TopoComplex)

subComplex = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'subComplex'), TopoComplexPropertyType, documentation='The property elements gml:subComplex, gml:superComplex and gml:maximalComplex provide an encoding for relationships between topology complexes as described for gml:TopoComplex above.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/topology.xsd', 342, 2))
_Namespace_gml.addCategoryObject('elementBinding', subComplex.name().localName(), subComplex)

superComplex = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'superComplex'), TopoComplexPropertyType, documentation='The property elements gml:subComplex, gml:superComplex and gml:maximalComplex provide an encoding for relationships between topology complexes as described for gml:TopoComplex above.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/topology.xsd', 347, 2))
_Namespace_gml.addCategoryObject('elementBinding', superComplex.name().localName(), superComplex)

maximalComplex = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'maximalComplex'), TopoComplexPropertyType, documentation='The property elements gml:subComplex, gml:superComplex and gml:maximalComplex provide an encoding for relationships between topology complexes as described for gml:TopoComplex above.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/topology.xsd', 352, 2))
_Namespace_gml.addCategoryObject('elementBinding', maximalComplex.name().localName(), maximalComplex)

topoPrimitiveMember = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'topoPrimitiveMember'), TopoPrimitiveMemberType, documentation='The gml:topoPrimitiveMember property element encodes for the relationship between a topology complex and a single topology primitive.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/topology.xsd', 357, 2))
_Namespace_gml.addCategoryObject('elementBinding', topoPrimitiveMember.name().localName(), topoPrimitiveMember)

unitOfMeasure = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'unitOfMeasure'), UnitOfMeasureType, documentation='The element gml:unitOfMeasure is a property element to refer to a unit of measure. This is an empty element which carries a reference to a unit of measure definition.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/units.xsd', 21, 1))
_Namespace_gml.addCategoryObject('elementBinding', unitOfMeasure.name().localName(), unitOfMeasure)

quantityType = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'quantityType'), StringOrRefType, documentation='The gml:quantityType property indicates the phenomenon to which the units apply. This element contains an informal description of the phenomenon or type of physical quantity that is measured or observed. When the physical quantity is the result of an observation or measurement, this term is known as observable type or measurand.\nThe use of gml:quantityType for references to remote values is deprecated.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/units.xsd', 48, 1))
_Namespace_gml.addCategoryObject('elementBinding', quantityType.name().localName(), quantityType)

quantityTypeReference = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'quantityTypeReference'), ReferenceType, documentation='The gml:quantityTypeReference property indicates the phenomenon to which the units apply. The content is a reference to a remote value.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/units.xsd', 54, 1))
_Namespace_gml.addCategoryObject('elementBinding', quantityTypeReference.name().localName(), quantityTypeReference)

Boolean_ = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'Boolean'), CTD_ANON_9, nillable=pyxb.binding.datatypes.boolean(1), location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/valueObjects.xsd', 24, 1))
_Namespace_gml.addCategoryObject('elementBinding', Boolean_.name().localName(), Boolean_)

BooleanList = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'BooleanList'), booleanOrNilReasonList, location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/valueObjects.xsd', 33, 1))
_Namespace_gml.addCategoryObject('elementBinding', BooleanList.name().localName(), BooleanList)

Category = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'Category'), CTD_ANON_10, nillable=pyxb.binding.datatypes.boolean(1), documentation='A gml:Category has an optional XML attribute codeSpace, whose value is a URI which identifies a dictionary, codelist or authority for the term.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/valueObjects.xsd', 34, 1))
_Namespace_gml.addCategoryObject('elementBinding', Category.name().localName(), Category)

Count = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'Count'), CTD_ANON_11, nillable=pyxb.binding.datatypes.boolean(1), location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/valueObjects.xsd', 47, 1))
_Namespace_gml.addCategoryObject('elementBinding', Count.name().localName(), Count)

CountList = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'CountList'), integerOrNilReasonList, location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/valueObjects.xsd', 56, 1))
_Namespace_gml.addCategoryObject('elementBinding', CountList.name().localName(), CountList)

valueProperty = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'valueProperty'), ValuePropertyType, documentation='Property that refers to, or contains, a Value. Convenience element for general use.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/valueObjects.xsd', 97, 1))
_Namespace_gml.addCategoryObject('elementBinding', valueProperty.name().localName(), valueProperty)

valueComponent = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'valueComponent'), ValuePropertyType, documentation='Property that refers to, or contains, a Value.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/valueObjects.xsd', 102, 1))
_Namespace_gml.addCategoryObject('elementBinding', valueComponent.name().localName(), valueComponent)

ValueArray = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'ValueArray'), ValueArrayType, documentation='A Value Array is used for homogeneous arrays of primitive and aggregate values.  \nThe member values may be scalars, composites, arrays or lists.\nValueArray has the same content model as CompositeValue, but the member values shall be homogeneous.  The element declaration contains a Schematron constraint which expresses this restriction precisely.  Since the members are homogeneous, the gml:referenceSystem (uom, codeSpace) may be specified on the gml:ValueArray itself and inherited by all the members if desired.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/valueObjects.xsd', 141, 1))
_Namespace_gml.addCategoryObject('elementBinding', ValueArray.name().localName(), ValueArray)

Length = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gco, 'Length'), LengthType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 123, 1))
_Namespace_gco.addCategoryObject('elementBinding', Length.name().localName(), Length)

Angle = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gco, 'Angle'), AngleType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 133, 1))
_Namespace_gco.addCategoryObject('elementBinding', Angle.name().localName(), Angle)

Scale = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gco, 'Scale'), ScaleType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 143, 1))
_Namespace_gco.addCategoryObject('elementBinding', Scale.name().localName(), Scale)

Distance = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gco, 'Distance'), LengthType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 153, 1))
_Namespace_gco.addCategoryObject('elementBinding', Distance.name().localName(), Distance)

MD_ImageDescription = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_ImageDescription'), MD_ImageDescription_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/content.xsd', 91, 1))
_Namespace_gmd.addCategoryObject('elementBinding', MD_ImageDescription.name().localName(), MD_ImageDescription)

DQ_TemporalValidity = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'DQ_TemporalValidity'), DQ_TemporalValidity_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 161, 1))
_Namespace_gmd.addCategoryObject('elementBinding', DQ_TemporalValidity.name().localName(), DQ_TemporalValidity)

DQ_TemporalConsistency = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'DQ_TemporalConsistency'), DQ_TemporalConsistency_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 177, 1))
_Namespace_gmd.addCategoryObject('elementBinding', DQ_TemporalConsistency.name().localName(), DQ_TemporalConsistency)

DQ_AccuracyOfATimeMeasurement = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'DQ_AccuracyOfATimeMeasurement'), DQ_AccuracyOfATimeMeasurement_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 193, 1))
_Namespace_gmd.addCategoryObject('elementBinding', DQ_AccuracyOfATimeMeasurement.name().localName(), DQ_AccuracyOfATimeMeasurement)

DQ_QuantitativeAttributeAccuracy = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'DQ_QuantitativeAttributeAccuracy'), DQ_QuantitativeAttributeAccuracy_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 209, 1))
_Namespace_gmd.addCategoryObject('elementBinding', DQ_QuantitativeAttributeAccuracy.name().localName(), DQ_QuantitativeAttributeAccuracy)

DQ_NonQuantitativeAttributeAccuracy = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'DQ_NonQuantitativeAttributeAccuracy'), DQ_NonQuantitativeAttributeAccuracy_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 225, 1))
_Namespace_gmd.addCategoryObject('elementBinding', DQ_NonQuantitativeAttributeAccuracy.name().localName(), DQ_NonQuantitativeAttributeAccuracy)

DQ_ThematicClassificationCorrectness = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'DQ_ThematicClassificationCorrectness'), DQ_ThematicClassificationCorrectness_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 241, 1))
_Namespace_gmd.addCategoryObject('elementBinding', DQ_ThematicClassificationCorrectness.name().localName(), DQ_ThematicClassificationCorrectness)

DQ_RelativeInternalPositionalAccuracy = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'DQ_RelativeInternalPositionalAccuracy'), DQ_RelativeInternalPositionalAccuracy_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 257, 1))
_Namespace_gmd.addCategoryObject('elementBinding', DQ_RelativeInternalPositionalAccuracy.name().localName(), DQ_RelativeInternalPositionalAccuracy)

DQ_GriddedDataPositionalAccuracy = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'DQ_GriddedDataPositionalAccuracy'), DQ_GriddedDataPositionalAccuracy_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 273, 1))
_Namespace_gmd.addCategoryObject('elementBinding', DQ_GriddedDataPositionalAccuracy.name().localName(), DQ_GriddedDataPositionalAccuracy)

DQ_AbsoluteExternalPositionalAccuracy = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'DQ_AbsoluteExternalPositionalAccuracy'), DQ_AbsoluteExternalPositionalAccuracy_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 289, 1))
_Namespace_gmd.addCategoryObject('elementBinding', DQ_AbsoluteExternalPositionalAccuracy.name().localName(), DQ_AbsoluteExternalPositionalAccuracy)

DQ_TopologicalConsistency = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'DQ_TopologicalConsistency'), DQ_TopologicalConsistency_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 305, 1))
_Namespace_gmd.addCategoryObject('elementBinding', DQ_TopologicalConsistency.name().localName(), DQ_TopologicalConsistency)

DQ_FormatConsistency = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'DQ_FormatConsistency'), DQ_FormatConsistency_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 321, 1))
_Namespace_gmd.addCategoryObject('elementBinding', DQ_FormatConsistency.name().localName(), DQ_FormatConsistency)

DQ_DomainConsistency = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'DQ_DomainConsistency'), DQ_DomainConsistency_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 337, 1))
_Namespace_gmd.addCategoryObject('elementBinding', DQ_DomainConsistency.name().localName(), DQ_DomainConsistency)

DQ_ConceptualConsistency = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'DQ_ConceptualConsistency'), DQ_ConceptualConsistency_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 353, 1))
_Namespace_gmd.addCategoryObject('elementBinding', DQ_ConceptualConsistency.name().localName(), DQ_ConceptualConsistency)

DQ_CompletenessOmission = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'DQ_CompletenessOmission'), DQ_CompletenessOmission_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 369, 1))
_Namespace_gmd.addCategoryObject('elementBinding', DQ_CompletenessOmission.name().localName(), DQ_CompletenessOmission)

DQ_CompletenessCommission = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'DQ_CompletenessCommission'), DQ_CompletenessCommission_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 385, 1))
_Namespace_gmd.addCategoryObject('elementBinding', DQ_CompletenessCommission.name().localName(), DQ_CompletenessCommission)

DS_Platform = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'DS_Platform'), DS_Platform_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataApplication.xsd', 118, 1))
_Namespace_gmd.addCategoryObject('elementBinding', DS_Platform.name().localName(), DS_Platform)

DS_Sensor = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'DS_Sensor'), DS_Sensor_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataApplication.xsd', 134, 1))
_Namespace_gmd.addCategoryObject('elementBinding', DS_Sensor.name().localName(), DS_Sensor)

DS_ProductionSeries = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'DS_ProductionSeries'), DS_ProductionSeries_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataApplication.xsd', 150, 1))
_Namespace_gmd.addCategoryObject('elementBinding', DS_ProductionSeries.name().localName(), DS_ProductionSeries)

DS_StereoMate = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'DS_StereoMate'), DS_StereoMate_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataApplication.xsd', 166, 1))
_Namespace_gmd.addCategoryObject('elementBinding', DS_StereoMate.name().localName(), DS_StereoMate)

MD_Georeferenceable = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_Georeferenceable'), MD_Georeferenceable_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/spatialRepresentation.xsd', 100, 1))
_Namespace_gmd.addCategoryObject('elementBinding', MD_Georeferenceable.name().localName(), MD_Georeferenceable)

MD_Georectified = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_Georectified'), MD_Georectified_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/spatialRepresentation.xsd', 148, 1))
_Namespace_gmd.addCategoryObject('elementBinding', MD_Georectified.name().localName(), MD_Georectified)

AbstractDiscreteCoverage = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractDiscreteCoverage'), DiscreteCoverageType, abstract=pyxb.binding.datatypes.boolean(1), documentation='A discrete coverage consists of a domain set, range set and optionally a coverage function. The domain set consists of either spatial or temporal geometry objects, finite in number. The range set is comprised of a finite number of attribute values each of which is associated to every direct position within any single spatiotemporal object in the domain. In other words, the range values are constant on each spatiotemporal object in the domain. This coverage function maps each element from the coverage domain to an element in its range. The coverageFunction element describes the mapping function.\nThis element serves as the head of a substitution group which may contain any discrete coverage whose type is derived from gml:DiscreteCoverageType.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coverage.xsd', 48, 1))
_Namespace_gml.addCategoryObject('elementBinding', AbstractDiscreteCoverage.name().localName(), AbstractDiscreteCoverage)

AbstractContinuousCoverage = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractContinuousCoverage'), AbstractContinuousCoverageType, abstract=pyxb.binding.datatypes.boolean(1), documentation='A continuous coverage as defined in ISO 19123 is a coverage that can return different values for the same feature attribute at different direct positions within a single spatiotemporal object in its spatiotemporal domain. The base type for continuous coverages is AbstractContinuousCoverageType.\nThe coverageFunction element describes the mapping function. \nThe abstract element gml:AbstractContinuousCoverage serves as the head of a substitution group which may contain any continuous coverage whose type is derived from gml:AbstractContinuousCoverageType.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coverage.xsd', 63, 1))
_Namespace_gml.addCategoryObject('elementBinding', AbstractContinuousCoverage.name().localName(), AbstractContinuousCoverage)

MultiPointCoverage = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'MultiPointCoverage'), DiscreteCoverageType, documentation='In a gml:MultiPointCoverage the domain set is a gml:MultiPoint, that is a collection of arbitrarily distributed geometric points.\nThe content model is identical with gml:DiscreteCoverageType, but that gml:domainSet shall have values gml:MultiPoint.\nIn a gml:MultiPointCoverage the mapping from the domain to the range is straightforward.\n-\tFor gml:DataBlock encodings the points of the gml:MultiPoint are mapped in document order to the tuples of the data block.\n-\tFor gml:CompositeValue encodings the points of the gml:MultiPoint are mapped to the members of the composite value in document order.\n-\tFor gml:File encodings the points of the gml:MultiPoint are mapped to the records of the file in sequential order.\n', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coverage.xsd', 236, 1))
_Namespace_gml.addCategoryObject('elementBinding', MultiPointCoverage.name().localName(), MultiPointCoverage)

MultiCurveCoverage = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'MultiCurveCoverage'), DiscreteCoverageType, documentation='In a gml:MultiCurveCoverage the domain is partioned into a collection of curves comprising a gml:MultiCurve.  The coverage function then maps each curve in the collection to a value in the range set.\nThe content model is identical with gml:DiscreteCoverageType, but that gml:domainSet shall have values gml:MultiCurve.\nIn a gml:MultiCurveCoverage the mapping from the domain to the range is straightforward.\n-\tFor gml:DataBlock encodings the curves of the gml:MultiCurve are mapped in document order to the tuples of the data block.\n-\tFor gml:CompositeValue encodings the curves of the gml:MultiCurve are mapped to the members of the composite value in document order.\n-\tFor gml:File encodings the curves of the gml:MultiCurve are mapped to the records of the file in sequential order.\n', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coverage.xsd', 247, 1))
_Namespace_gml.addCategoryObject('elementBinding', MultiCurveCoverage.name().localName(), MultiCurveCoverage)

MultiSurfaceCoverage = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'MultiSurfaceCoverage'), DiscreteCoverageType, documentation='In a gml:MultiSurfaceCoverage the domain is partioned into a collection of surfaces comprising a gml:MultiSurface.  The coverage function than maps each surface in the collection to a value in the range set.\nThe content model is identical with gml:DiscreteCoverageType, but that gml:domainSet shall have values gml:MultiSurface.\nIn a gml:MultiSurfaceCoverage the mapping from the domain to the range is straightforward.\n-\tFor gml:DataBlock encodings the surfaces of the gml:MultiSurface are mapped in document order to the tuples of the data block.\n-\tFor gml:CompositeValue encodings the surfaces of the gml:MultiSurface are mapped to the members of the composite value in document order.\n-\tFor gml:File encodings the surfaces of the gml:MultiSurface are mapped to the records of the file in sequential order.\n', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coverage.xsd', 258, 1))
_Namespace_gml.addCategoryObject('elementBinding', MultiSurfaceCoverage.name().localName(), MultiSurfaceCoverage)

MultiSolidCoverage = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'MultiSolidCoverage'), DiscreteCoverageType, documentation='In a gml:MultiSolidCoverage the domain is partioned into a collection of solids comprising a gml:MultiSolid.  The coverage function than maps each solid in the collection to a value in the range set.\nThe content model is identical with gml:DiscreteCoverageType, but that gml:domainSet shall have values gml:MultiSolid.\nIn a gml:MultiSolidCoverage the mapping from the domain to the range is straightforward.\n-\tFor gml:DataBlock encodings the solids of the gml:MultiSolid are mapped in document order to the tuples of the data block.\n-\tFor gml:CompositeValue encodings the solids of the gml:MultiSolid are mapped to the members of the composite value in document order.\n-\tFor gml:File encodings the solids of the gml:MultiSolid are mapped to the records of the file in sequential order.\n', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coverage.xsd', 269, 1))
_Namespace_gml.addCategoryObject('elementBinding', MultiSolidCoverage.name().localName(), MultiSolidCoverage)

GridCoverage = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'GridCoverage'), DiscreteCoverageType, documentation='A gml:GriddedCoverage is a discrete point coverage in which the domain set is a geometric grid of points.\nNote that this is the same as the gml:MultiPointCoverage except that we have a gml:Grid to describe the domain.\nThe simple gridded coverage is not geometrically referenced and hence no geometric positions are assignable to the points in the grid. Such geometric positioning is introduced in the gml:RectifiedGridCoverage.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coverage.xsd', 280, 1))
_Namespace_gml.addCategoryObject('elementBinding', GridCoverage.name().localName(), GridCoverage)

RectifiedGridCoverage = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'RectifiedGridCoverage'), DiscreteCoverageType, documentation='The gml:RectifiedGridCoverage is a discrete point coverage based on a rectified grid. It is similar to the grid coverage except that the points of the grid are geometrically referenced. The rectified grid coverage has a domain that is a gml:RectifiedGrid geometry.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coverage.xsd', 287, 1))
_Namespace_gml.addCategoryObject('elementBinding', RectifiedGridCoverage.name().localName(), RectifiedGridCoverage)

greenwichLongitude = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'greenwichLongitude'), AngleType, documentation='gml:greenwichLongitude is the longitude of the prime meridian measured from the Greenwich meridian, positive eastward. If the value of the prime meridian "name" is "Greenwich" then the value of greenwichLongitude shall be 0 degrees.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/datums.xsd', 159, 1))
_Namespace_gml.addCategoryObject('elementBinding', greenwichLongitude.name().localName(), greenwichLongitude)

priorityLocation = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'priorityLocation'), PriorityLocationPropertyType, documentation='', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 790, 1))
_Namespace_gml.addCategoryObject('elementBinding', priorityLocation.name().localName(), priorityLocation)

FeatureCollection = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'FeatureCollection'), FeatureCollectionType, documentation='', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 860, 1))
_Namespace_gml.addCategoryObject('elementBinding', FeatureCollection.name().localName(), FeatureCollection)

DefinitionCollection = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'DefinitionCollection'), DictionaryType, documentation='', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 878, 1))
_Namespace_gml.addCategoryObject('elementBinding', DefinitionCollection.name().localName(), DefinitionCollection)

DefinitionProxy = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'DefinitionProxy'), DefinitionProxyType, documentation='', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 901, 1))
_Namespace_gml.addCategoryObject('elementBinding', DefinitionProxy.name().localName(), DefinitionProxy)

Dictionary = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'Dictionary'), DictionaryType, documentation='Sets of definitions may be collected into dictionaries or collections.\nA gml:Dictionary is a non-abstract collection of definitions.\nThe gml:Dictionary content model adds a list of gml:dictionaryEntry properties that contain or reference gml:Definition objects.  A database handle (gml:id attribute) is required, in order that this collection may be referred to. The standard gml:identifier, gml:description, gml:descriptionReference and gml:name properties are available to reference or contain more information about this dictionary. The gml:description and gml:descriptionReference property elements may be used for a description of this dictionary. The derived gml:name element may be used for the name(s) of this dictionary. for remote definiton references gml:dictionaryEntry shall be used. If a Definition object contained within a Dictionary uses the descriptionReference property to refer to a remote definition, then this enables the inclusion of a remote definition in a local dictionary, giving a handle and identifier in the context of the local dictionary.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 55, 1))
_Namespace_gml.addCategoryObject('elementBinding', Dictionary.name().localName(), Dictionary)

DynamicFeatureCollection = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'DynamicFeatureCollection'), DynamicFeatureCollectionType, documentation='A gml:DynamicFeatureCollection is a feature collection that has a gml:validTime property (i.e. is a snapshot of the feature collection) or which has a gml:history property that contains one or more gml:AbstractTimeSlices each of which contain values of the time varying properties of the feature collection.  Note that the gml:DynamicFeatureCollection may be one of the following:\n1.\tA feature collection which consists of static feature members (members do not change in time) but which has properties of the collection object as a whole that do change in time .  \n2.\tA feature collection which consists of dynamic feature members (the members are gml:DynamicFeatures) but which also has properties of the collection as a whole that vary in time.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dynamicFeature.xsd', 51, 1))
_Namespace_gml.addCategoryObject('elementBinding', DynamicFeatureCollection.name().localName(), DynamicFeatureCollection)

MultiGeometry = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'MultiGeometry'), MultiGeometryType, documentation='gml:MultiGeometry is a collection of one or more GML geometry objects of arbitrary type. \nThe members of the geometric aggregate may be specified either using the "standard" property (gml:geometryMember) or the array property (gml:geometryMembers). It is also valid to use both the "standard" and the array properties in the same collection.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryAggregates.xsd', 37, 1))
_Namespace_gml.addCategoryObject('elementBinding', MultiGeometry.name().localName(), MultiGeometry)

MultiPoint = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'MultiPoint'), MultiPointType, documentation='A gml:MultiPoint consists of one or more gml:Points.\nThe members of the geometric aggregate may be specified either using the "standard" property (gml:pointMember) or the array property (gml:pointMembers). It is also valid to use both the "standard" and the array properties in the same collection.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryAggregates.xsd', 73, 1))
_Namespace_gml.addCategoryObject('elementBinding', MultiPoint.name().localName(), MultiPoint)

MultiCurve = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'MultiCurve'), MultiCurveType, documentation='A gml:MultiCurve is defined by one or more gml:AbstractCurves.\nThe members of the geometric aggregate may be specified either using the "standard" property (gml:curveMember) or the array property (gml:curveMembers). It is also valid to use both the "standard" and the array properties in the same collection.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryAggregates.xsd', 109, 1))
_Namespace_gml.addCategoryObject('elementBinding', MultiCurve.name().localName(), MultiCurve)

MultiSurface = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'MultiSurface'), MultiSurfaceType, documentation='A gml:MultiSurface is defined by one or more gml:AbstractSurfaces.\nThe members of the geometric aggregate may be specified either using the "standard" property (gml:surfaceMember) or the array property (gml:surfaceMembers). It is also valid to use both the "standard" and the array properties in the same collection.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryAggregates.xsd', 140, 1))
_Namespace_gml.addCategoryObject('elementBinding', MultiSurface.name().localName(), MultiSurface)

MultiSolid = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'MultiSolid'), MultiSolidType, documentation='A gml:MultiSolid is defined by one or more gml:AbstractSolids.\nThe members of the geometric aggregate may be specified either using the "standard" property (gml:solidMember) or the array property (gml:solidMembers). It is also valid to use both the "standard" and the array properties in the same collection.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryAggregates.xsd', 171, 1))
_Namespace_gml.addCategoryObject('elementBinding', MultiSolid.name().localName(), MultiSolid)

Point = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'Point'), PointType, documentation='A Point is defined by a single coordinate tuple. The direct position of a point is specified by the pos element which is of type DirectPositionType.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic0d1d.xsd', 189, 1))
_Namespace_gml.addCategoryObject('elementBinding', Point.name().localName(), Point)

AbstractCurve = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractCurve'), AbstractCurveType, abstract=pyxb.binding.datatypes.boolean(1), documentation='The AbstractCurve element is the abstract head of the substitution group for all (continuous) curve elements.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic0d1d.xsd', 226, 1))
_Namespace_gml.addCategoryObject('elementBinding', AbstractCurve.name().localName(), AbstractCurve)

AbstractSurface = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractSurface'), AbstractSurfaceType, abstract=pyxb.binding.datatypes.boolean(1), documentation='The AbstractSurface element is the abstract head of the substitution group for all (continuous) surface elements.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic2d.xsd', 22, 1))
_Namespace_gml.addCategoryObject('elementBinding', AbstractSurface.name().localName(), AbstractSurface)

Circle = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'Circle'), CircleType, documentation='A Circle is an arc whose ends coincide to form a simple closed loop. The three control points shall be distinct non-co-linear points for the circle to be unambiguously defined. The arc is simply extended past the third control point until the first control point is encountered.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 173, 1))
_Namespace_gml.addCategoryObject('elementBinding', Circle.name().localName(), Circle)

Cone = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'Cone'), ConeType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 704, 1))
_Namespace_gml.addCategoryObject('elementBinding', Cone.name().localName(), Cone)

Cylinder = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'Cylinder'), CylinderType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 713, 1))
_Namespace_gml.addCategoryObject('elementBinding', Cylinder.name().localName(), Cylinder)

Sphere = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'Sphere'), SphereType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 722, 1))
_Namespace_gml.addCategoryObject('elementBinding', Sphere.name().localName(), Sphere)

AbstractSolid = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractSolid'), AbstractSolidType, abstract=pyxb.binding.datatypes.boolean(1), documentation='The AbstractSolid element is the abstract head of the substituition group for all (continuous) solid elements.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 775, 1))
_Namespace_gml.addCategoryObject('elementBinding', AbstractSolid.name().localName(), AbstractSolid)

RectifiedGrid = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'RectifiedGrid'), RectifiedGridType, documentation='A rectified grid is a grid for which there is an affine transformation between the grid coordinates and the coordinates of an external coordinate reference system. It is defined by specifying the position (in some geometric space) of the grid "origin" and of the vectors that specify the post locations.\nNote that the grid limits (post indexes) and axis name properties are inherited from gml:GridType and that gml:RectifiedGrid adds a gml:origin property (contains or references a gml:Point) and a set of gml:offsetVector properties.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/grids.xsd', 48, 1))
_Namespace_gml.addCategoryObject('elementBinding', RectifiedGrid.name().localName(), RectifiedGrid)

angle = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'angle'), AngleType, documentation='The gml:angle property element is used to record the value of an angle quantity as a single number, with its units.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/measures.xsd', 63, 1))
_Namespace_gml.addCategoryObject('elementBinding', angle.name().localName(), angle)

DirectedObservation = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'DirectedObservation'), DirectedObservationType, documentation='A gml:DirectedObservation is the same as an observation except that it adds an additional gml:direction property. This is the direction in which the observation was acquired. Clearly this applies only to certain types of observations such as visual observations by people, or observations obtained from terrestrial cameras.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/observation.xsd', 67, 1))
_Namespace_gml.addCategoryObject('elementBinding', DirectedObservation.name().localName(), DirectedObservation)

AbstractTimeGeometricPrimitive = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractTimeGeometricPrimitive'), AbstractTimeGeometricPrimitiveType, abstract=pyxb.binding.datatypes.boolean(1), documentation='gml:TimeGeometricPrimitive acts as the head of a substitution group for geometric temporal primitives.\nA temporal geometry shall be associated with a temporal reference system through the frame attribute that provides a URI reference that identifies a description of the reference system. Following ISO 19108, the Gregorian calendar with UTC is the default reference system, but others may also be used. The GPS calendar is an alternative reference systems in common use.\nThe two geometric primitives in the temporal dimension are the instant and the period. GML components are defined to support these as follows.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporal.xsd', 95, 1))
_Namespace_gml.addCategoryObject('elementBinding', AbstractTimeGeometricPrimitive.name().localName(), AbstractTimeGeometricPrimitive)

TimeReferenceSystem = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'TimeReferenceSystem'), TimeReferenceSystemType, documentation='A reference system is characterized in terms of its domain of validity: the spatial and temporal extent over which it is applicable. The basic GML element for temporal reference systems is gml:TimeReferenceSystem.  Its content model extends gml:DefinitionType with one additional property, gml:domainOfValidity.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporalReferenceSystems.xsd', 17, 1))
_Namespace_gml.addCategoryObject('elementBinding', TimeReferenceSystem.name().localName(), TimeReferenceSystem)

TimeCalendarEra = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'TimeCalendarEra'), TimeCalendarEraType, documentation='gml:TimeCalendarEra inherits basic properties from gml:DefinitionType and has the following additional properties:\n-\tgml:referenceEvent is the name or description of a mythical or historic event which fixes the position of the base scale of the calendar era.  This is given as text or using a link to description held elsewhere.\n-\tgml:referenceDate specifies the date of the referenceEvent expressed as a date in the given calendar.  In most calendars, this date is the origin (i.e., the first day) of the scale, but this is not always true.\n-\tgml:julianReference specifies the Julian date that corresponds to the reference date.  The Julian day number is an integer value; the Julian date is a decimal value that allows greater resolution.  Transforming calendar dates to and from Julian dates provides a relatively simple basis for transforming dates from one calendar to another.\n-\tgml:epochOfUse is the period for which the calendar era was used as a basis for dating.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporalReferenceSystems.xsd', 69, 1))
_Namespace_gml.addCategoryObject('elementBinding', TimeCalendarEra.name().localName(), TimeCalendarEra)

TimeOrdinalEra = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'TimeOrdinalEra'), TimeOrdinalEraType, documentation='Its content model follows the pattern of gml:TimeEdge, inheriting standard properties from gml:DefinitionType, and adding gml:start, gml:end and gml:extent properties, a set of gml:member properties which indicate ordered gml:TimeOrdinalEra elements, and a gml:group property which points to the parent era.\nThe recursive inclusion of gml:TimeOrdinalEra elements allow the construction of an arbitrary depth hierarchical ordinal reference schema, such that an ordinal era at a given level of the hierarchy includes a sequence of shorter, coterminous ordinal eras.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporalReferenceSystems.xsd', 159, 1))
_Namespace_gml.addCategoryObject('elementBinding', TimeOrdinalEra.name().localName(), TimeOrdinalEra)

AbstractTimeTopologyPrimitive = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractTimeTopologyPrimitive'), AbstractTimeTopologyPrimitiveType, abstract=pyxb.binding.datatypes.boolean(1), documentation='gml:TimeTopologyPrimitive acts as the head of a substitution group for topological temporal primitives.\nTemporal topology primitives shall imply the ordering information between features or feature properties. The temporal connection of features can be examined if they have temporal topology primitives as values of their properties. Usually, an instantaneous feature associates with a time node, and a static feature associates with a time edge.  A feature with both modes associates with the temporal topology primitive: a supertype of time nodes and time edges.\nA topological primitive is always connected to one or more other topological primitives, and is, therefore, always a member of a topological complex. In a GML instance, this will often be indicated by the primitives being described by elements that are descendents of an element describing a complex. However, in order to support the case where a temporal topological primitive is described in another context, the optional complex property is provided, which carries a reference to the parent temporal topological complex.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporalTopology.xsd', 15, 1))
_Namespace_gml.addCategoryObject('elementBinding', AbstractTimeTopologyPrimitive.name().localName(), AbstractTimeTopologyPrimitive)

TimeTopologyComplex = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'TimeTopologyComplex'), TimeTopologyComplexType, documentation='A temporal topology complex shall be the connected acyclic directed graph composed of temporal topological primitives, i.e. time nodes and time edges. Because a time edge may not exist without two time nodes on its boundaries, static features have time edges from a temporal topology complex as the values of their temporal properties, regardless of explicit declarations.\nA temporal topology complex expresses a linear or a non-linear graph. A temporal linear graph, composed of a sequence of time edges, provides a lineage described only by "substitution" of feature instances or feature element values. A time node as the start or the end of the graph connects with at least one time edge. A time node other than the start and the end shall connect to at least two time edges: one of starting from the node, and another ending at the node.\nA temporal topological complex is a set of connected temporal topological primitives. The member primtives are indicated, either by reference or by value, using the primitive property.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporalTopology.xsd', 41, 1))
_Namespace_gml.addCategoryObject('elementBinding', TimeTopologyComplex.name().localName(), TimeTopologyComplex)

Node = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'Node'), NodeType, documentation='gml:Node represents the 0-dimensional primitive.\nThe optional coboundary of a node (gml:directedEdge) is a sequence of directed edges which are incident on this node. Edges emanating from this node appear in the node coboundary with a negative orientation. \nIf provided, the aggregationType attribute shall have the value "sequence".\nA node may optionally be realised by a 0-dimensional geometric primitive (gml:pointProperty).', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/topology.xsd', 83, 2))
_Namespace_gml.addCategoryObject('elementBinding', Node.name().localName(), Node)

Edge = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'Edge'), EdgeType, documentation='gml:Edge represents the 1-dimensional primitive.\nThe topological boundary of an Edge (gml:directedNode) consists of a negatively directed start Node and a positively directed end Node.   \nThe optional coboundary of an edge (gml:directedFace) is a circular sequence of directed faces which are incident on this edge in document order. In the 2D case, the orientation of the face on the left of the edge is "+"; the orientation of the face on the right on its right is "-". \nIf provided, the aggregationType attribute shall have the value "sequence".\nAn edge may optionally be realised by a 1-dimensional geometric primitive (gml:curveProperty).', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/topology.xsd', 117, 2))
_Namespace_gml.addCategoryObject('elementBinding', Edge.name().localName(), Edge)

Face = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'Face'), FaceType, documentation='gml:Face represents the 2-dimensional topology primitive.\nThe topological boundary of a face (gml:directedEdge) consists of a sequence of directed edges. If provided, the aggregationType attribute shall have the value "sequence".\nThe optional coboundary of a face (gml:directedTopoSolid) is a pair of directed solids which are bounded by this face. A positively directed solid corresponds to a solid which lies in the direction of the negatively directed normal to the face in any geometric realisation. \nA face may optionally be realised by a 2-dimensional geometric primitive (gml:surfaceProperty).', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/topology.xsd', 157, 2))
_Namespace_gml.addCategoryObject('elementBinding', Face.name().localName(), Face)

TopoSolid = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'TopoSolid'), TopoSolidType, documentation='gml:TopoSolid represents the 3-dimensional topology primitive. \nThe topological boundary of a solid (gml:directedFace) consists of a set of directed faces.\nA solid may optionally be realised by a 3-dimensional geometric primitive (gml:solidProperty).', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/topology.xsd', 195, 2))
_Namespace_gml.addCategoryObject('elementBinding', TopoSolid.name().localName(), TopoSolid)

UnitDefinition = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'UnitDefinition'), UnitDefinitionType, documentation='A gml:UnitDefinition is a general definition of a unit of measure. This generic element is used only for units for which no relationship with other units or units systems is known.\nThe content model of gml:UnitDefinition adds three additional properties to gml:Definition, gml:quantityType, gml:quantityTypeReference and gml:catalogSymbol.  \nThe gml:catalogSymbol property optionally gives the short symbol used for this unit. This element is usually used when the relationship of this unit to other units or units systems is unknown.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/units.xsd', 30, 1))
_Namespace_gml.addCategoryObject('elementBinding', UnitDefinition.name().localName(), UnitDefinition)

derivationUnitTerm = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'derivationUnitTerm'), DerivationUnitTermType, documentation='A set of gml:derivationUnitTerm elements describes a derived unit of measure.  Each element carries an integer exponent.  The terms are combined by raising each referenced unit to the power of its exponent and forming the product.\nThis unit term references another unit of measure (uom) and provides an integer exponent applied to that unit in defining the compound unit. The exponent may be positive or negative, but not zero.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/units.xsd', 95, 1))
_Namespace_gml.addCategoryObject('elementBinding', derivationUnitTerm.name().localName(), derivationUnitTerm)

conversionToPreferredUnit = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'conversionToPreferredUnit'), ConversionToPreferredUnitType, documentation='The elements gml:conversionToPreferredUnit and gml:roughConversionToPreferredUnit represent parameters used to convert conventional units to preferred units for this physical quantity type.  A preferred unit is either a Base Unit or a Derived Unit that is selected for all values of one physical quantity type.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/units.xsd', 127, 1))
_Namespace_gml.addCategoryObject('elementBinding', conversionToPreferredUnit.name().localName(), conversionToPreferredUnit)

roughConversionToPreferredUnit = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'roughConversionToPreferredUnit'), ConversionToPreferredUnitType, documentation='The elements gml:conversionToPreferredUnit and gml:roughConversionToPreferredUnit represent parameters used to convert conventional units to preferred units for this physical quantity type.  A preferred unit is either a Base Unit or a Derived Unit that is selected for all values of one physical quantity type.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/units.xsd', 132, 1))
_Namespace_gml.addCategoryObject('elementBinding', roughConversionToPreferredUnit.name().localName(), roughConversionToPreferredUnit)

CategoryList = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'CategoryList'), CodeOrNilReasonListType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/valueObjects.xsd', 46, 1))
_Namespace_gml.addCategoryObject('elementBinding', CategoryList.name().localName(), CategoryList)

Quantity = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'Quantity'), CTD_ANON_12, nillable=pyxb.binding.datatypes.boolean(1), documentation='An XML attribute uom ("unit of measure") is required, whose value is a URI which identifies the definition of a ratio scale or units by which the numeric value shall be multiplied, or an interval or position scale on which the value occurs.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/valueObjects.xsd', 57, 1))
_Namespace_gml.addCategoryObject('elementBinding', Quantity.name().localName(), Quantity)

QuantityList = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'QuantityList'), MeasureOrNilReasonListType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/valueObjects.xsd', 69, 1))
_Namespace_gml.addCategoryObject('elementBinding', QuantityList.name().localName(), QuantityList)

CountExtent = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'CountExtent'), CountExtentType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/valueObjects.xsd', 167, 1))
_Namespace_gml.addCategoryObject('elementBinding', CountExtent.name().localName(), CountExtent)

AbstractCoordinateOperation = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractCoordinateOperation'), AbstractCoordinateOperationType, abstract=pyxb.binding.datatypes.boolean(1), documentation='gml:AbstractCoordinateOperation is a mathematical operation on coordinates that transforms or converts coordinates to another coordinate reference system. Many but not all coordinate operations (from CRS A to CRS B) also uniquely define the inverse operation (from CRS B to CRS A). In some cases, the operation method algorithm for the inverse operation is the same as for the forward algorithm, but the signs of some operation parameter values shall be reversed. In other cases, different algorithms are required for the forward and inverse operations, but the same operation parameter values are used. If (some) entirely different parameter values are needed, a different coordinate operation shall be defined.\nThe optional coordinateOperationAccuracy property elements provide estimates of the impact of this coordinate operation on point position accuracy.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 23, 1))
_Namespace_gml.addCategoryObject('elementBinding', AbstractCoordinateOperation.name().localName(), AbstractCoordinateOperation)

AbstractSingleOperation = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractSingleOperation'), AbstractCoordinateOperationType, abstract=pyxb.binding.datatypes.boolean(1), documentation='gml:AbstractSingleOperation is a single (not concatenated) coordinate operation.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 78, 1))
_Namespace_gml.addCategoryObject('elementBinding', AbstractSingleOperation.name().localName(), AbstractSingleOperation)

OperationMethod = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'OperationMethod'), OperationMethodType, documentation='gml:OperationMethod is a method (algorithm or procedure) used to perform a coordinate operation. Most operation methods use a number of operation parameters, although some coordinate conversions use none. Each coordinate operation using the method assigns values to these parameters.\nThe parameter elements are an unordered list of associations to the set of operation parameters and parameter groups used by this operation method.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 385, 1))
_Namespace_gml.addCategoryObject('elementBinding', OperationMethod.name().localName(), OperationMethod)

AbstractGeneralOperationParameter = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractGeneralOperationParameter'), AbstractGeneralOperationParameterType, abstract=pyxb.binding.datatypes.boolean(1), documentation='gml:GeneralOperationParameter is the abstract definition of a parameter or group of parameters used by an operation method.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 446, 1))
_Namespace_gml.addCategoryObject('elementBinding', AbstractGeneralOperationParameter.name().localName(), AbstractGeneralOperationParameter)

AbstractSingleCRS = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractSingleCRS'), AbstractCRSType, abstract=pyxb.binding.datatypes.boolean(1), documentation='gml:AbstractSingleCRS implements a coordinate reference system consisting of one coordinate system and one datum (as opposed to a Compound CRS).', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateReferenceSystems.xsd', 18, 1))
_Namespace_gml.addCategoryObject('elementBinding', AbstractSingleCRS.name().localName(), AbstractSingleCRS)

CoordinateSystemAxis = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'CoordinateSystemAxis'), CoordinateSystemAxisType, documentation='gml:CoordinateSystemAxis is a definition of a coordinate system axis.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateSystems.xsd', 19, 1))
_Namespace_gml.addCategoryObject('elementBinding', CoordinateSystemAxis.name().localName(), CoordinateSystemAxis)

AbstractCoordinateSystem = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractCoordinateSystem'), AbstractCoordinateSystemType, abstract=pyxb.binding.datatypes.boolean(1), documentation='gml:AbstractCoordinateSystem is a coordinate system (CS) is the non-repeating sequence of coordinate system axes that spans a given coordinate space. A CS is derived from a set of mathematical rules for specifying how coordinates in a given space are to be assigned to points. The coordinate values in a coordinate tuple shall be recorded in the order in which the coordinate system axes associations are recorded. This abstract complex type shall not be used, extended, or restricted, in an Application Schema, to define a concrete subtype with a meaning equivalent to a concrete subtype specified in this document.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateSystems.xsd', 78, 1))
_Namespace_gml.addCategoryObject('elementBinding', AbstractCoordinateSystem.name().localName(), AbstractCoordinateSystem)

AbstractDatum = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractDatum'), AbstractDatumType, abstract=pyxb.binding.datatypes.boolean(1), documentation='A gml:AbstractDatum specifies the relationship of a coordinate system to the earth, thus creating a coordinate reference system. A datum uses a parameter or set of parameters that determine the location of the origin of the coordinate reference system. Each datum subtype may be associated with only specific types of coordinate systems. This abstract complex type shall not be used, extended, or restricted, in a GML Application Schema, to define a concrete subtype with a meaning equivalent to a concrete subtype specified in this document.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/datums.xsd', 21, 1))
_Namespace_gml.addCategoryObject('elementBinding', AbstractDatum.name().localName(), AbstractDatum)

Ellipsoid = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'Ellipsoid'), EllipsoidType, documentation='A gml:Ellipsoid is a geometric figure that may be used to describe the approximate shape of the earth. In mathematical terms, it is a surface formed by the rotation of an ellipse about its minor axis.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/datums.xsd', 95, 1))
_Namespace_gml.addCategoryObject('elementBinding', Ellipsoid.name().localName(), Ellipsoid)

PrimeMeridian = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'PrimeMeridian'), PrimeMeridianType, documentation='A gml:PrimeMeridian defines the origin from which longitude values are determined. The default value for the prime meridian gml:identifier value is "Greenwich".', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/datums.xsd', 145, 1))
_Namespace_gml.addCategoryObject('elementBinding', PrimeMeridian.name().localName(), PrimeMeridian)

AbstractOperation = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractOperation'), AbstractCoordinateOperationType, abstract=pyxb.binding.datatypes.boolean(1), documentation='', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 83, 1))
_Namespace_gml.addCategoryObject('elementBinding', AbstractOperation.name().localName(), AbstractOperation)

LineString = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'LineString'), LineStringType, documentation='A LineString is a special curve that consists of a single segment with linear interpolation. It is defined by two or more coordinate tuples, with linear interpolation between them. The number of direct positions in the list shall be at least two.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic0d1d.xsd', 272, 1))
_Namespace_gml.addCategoryObject('elementBinding', LineString.name().localName(), LineString)

Polygon = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'Polygon'), PolygonType, documentation='A Polygon is a special surface that is defined by a single surface patch (see D.3.6). The boundary of this patch is coplanar and the polygon uses planar interpolation in its interior. \nThe elements exterior and interior describe the surface boundary of the polygon.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic2d.xsd', 61, 1))
_Namespace_gml.addCategoryObject('elementBinding', Polygon.name().localName(), Polygon)

AbstractRing = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractRing'), AbstractRingType, abstract=pyxb.binding.datatypes.boolean(1), documentation='An abstraction of a ring to support surface boundaries of different complexity.\nThe AbstractRing element is the abstract head of the substituition group for all closed boundaries of a surface patch.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic2d.xsd', 84, 1))
_Namespace_gml.addCategoryObject('elementBinding', AbstractRing.name().localName(), AbstractRing)

CompositeCurve = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'CompositeCurve'), CompositeCurveType, documentation='A gml:CompositeCurve is represented by a sequence of (orientable) curves such that each curve in the sequence terminates at the start point of the subsequent curve in the list. \ncurveMember references or contains inline one curve in the composite curve. \nThe curves are contiguous, the collection of curves is ordered. Therefore, if provided, the aggregationType attribute shall have the value "sequence".', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryComplexes.xsd', 54, 1))
_Namespace_gml.addCategoryObject('elementBinding', CompositeCurve.name().localName(), CompositeCurve)

CompositeSurface = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'CompositeSurface'), CompositeSurfaceType, documentation='A gml:CompositeSurface is represented by a set of orientable surfaces. It is geometry type with all the geometric properties of a (primitive) surface. Essentially, a composite surface is a collection of surfaces that join in pairs on common boundary curves and which, when considered as a whole, form a single surface.\nsurfaceMember references or contains inline one surface in the composite surface. \nThe surfaces are contiguous.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryComplexes.xsd', 71, 1))
_Namespace_gml.addCategoryObject('elementBinding', CompositeSurface.name().localName(), CompositeSurface)

CompositeSolid = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'CompositeSolid'), CompositeSolidType, documentation='gml:CompositeSolid implements ISO 19107 GM_CompositeSolid (see ISO 19107:2003, 6.6.7) as specified in D.2.3.6. \nA gml:CompositeSolid is represented by a set of orientable surfaces. It is a geometry type with all the geometric properties of a (primitive) solid. Essentially, a composite solid is a collection of solids that join in pairs on common boundary surfaces and which, when considered as a whole, form a single solid. \nsolidMember references or contains one solid in the composite solid. The solids are contiguous.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryComplexes.xsd', 88, 1))
_Namespace_gml.addCategoryObject('elementBinding', CompositeSolid.name().localName(), CompositeSolid)

Curve = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'Curve'), CurveType, documentation='A curve is a 1-dimensional primitive. Curves are continuous, connected, and have a measurable length in terms of the coordinate system. \nA curve is composed of one or more curve segments. Each curve segment within a curve may be defined using a different interpolation method. The curve segments are connected to one another, with the end point of each segment except the last being the start point of the next segment in the segment list.\nThe orientation of the curve is positive.\nThe element segments encapsulates the segments of the curve.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 24, 1))
_Namespace_gml.addCategoryObject('elementBinding', Curve.name().localName(), Curve)

OrientableCurve = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'OrientableCurve'), OrientableCurveType, documentation='OrientableCurve consists of a curve and an orientation. If the orientation is "+", then the OrientableCurve is identical to the baseCurve. If the orientation is "-", then the OrientableCurve is related to another AbstractCurve with a parameterization that reverses the sense of the curve traversal.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 47, 1))
_Namespace_gml.addCategoryObject('elementBinding', OrientableCurve.name().localName(), OrientableCurve)

Surface = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'Surface'), SurfaceType, documentation='A Surface is a 2-dimensional primitive and is composed of one or more surface patches as specified in ISO 19107:2003, 6.3.17.1. The surface patches are connected to one another.\npatches encapsulates the patches of the surface.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 507, 1))
_Namespace_gml.addCategoryObject('elementBinding', Surface.name().localName(), Surface)

OrientableSurface = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'OrientableSurface'), OrientableSurfaceType, documentation='OrientableSurface consists of a surface and an orientation. If the orientation is "+", then the OrientableSurface is identical to the baseSurface. If the orientation is "-", then the OrientableSurface is a reference to a gml:AbstractSurface with an up-normal that reverses the direction for this OrientableSurface, the sense of "the top of the surface".', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 528, 1))
_Namespace_gml.addCategoryObject('elementBinding', OrientableSurface.name().localName(), OrientableSurface)

PolyhedralSurface = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'PolyhedralSurface'), SurfaceType, documentation='A polyhedral surface is a surface composed of polygon patches connected along their common boundary curves. This differs from the surface type only in the restriction on the types of surface patches acceptable.\npolygonPatches encapsulates the polygon patches of the polyhedral surface.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 723, 1))
_Namespace_gml.addCategoryObject('elementBinding', PolyhedralSurface.name().localName(), PolyhedralSurface)

TriangulatedSurface = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'TriangulatedSurface'), SurfaceType, documentation='A triangulated surface is a polyhedral surface that is composed only of triangles. There is no restriction on how the triangulation is derived.\ntrianglePatches encapsulates the triangles of the triangulated surface.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 729, 1))
_Namespace_gml.addCategoryObject('elementBinding', TriangulatedSurface.name().localName(), TriangulatedSurface)

Solid = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'Solid'), SolidType, documentation='A solid is the basis for 3-dimensional geometry. The extent of a solid is defined by the boundary surfaces as specified in ISO 19107:2003, 6.3.18. exterior specifies the outer boundary, interior the inner boundary of the solid.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 814, 1))
_Namespace_gml.addCategoryObject('elementBinding', Solid.name().localName(), Solid)

Shell = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'Shell'), ShellType, documentation='A shell is used to represent a single connected component of a solid boundary as specified in ISO 19107:2003, 6.3.8.\nEvery gml:surfaceMember references or contains one surface, i.e. any element which is substitutable for gml:AbstractSurface. In the context of a shell, the surfaces describe the boundary of the solid. \nIf provided, the aggregationType attribute shall have the value "set".\n', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 829, 1))
_Namespace_gml.addCategoryObject('elementBinding', Shell.name().localName(), Shell)

DirectedObservationAtDistance = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'DirectedObservationAtDistance'), DirectedObservationAtDistanceType, documentation='gml:DirectedObservationAtDistance adds an additional distance property. This is the distance from the observer to the subject of the observation. Clearly this applies only to certain types of observations such as visual observations by people, or observations obtained from terrestrial cameras.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/observation.xsd', 81, 1))
_Namespace_gml.addCategoryObject('elementBinding', DirectedObservationAtDistance.name().localName(), DirectedObservationAtDistance)

AbstractCRS = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractCRS'), AbstractCRSType, abstract=pyxb.binding.datatypes.boolean(1), documentation='gml:AbstractCRS specifies a coordinate reference system which is usually single but may be compound. This abstract complex type shall not be used, extended, or restricted, in a GML Application Schema, to define a concrete subtype with a meaning equivalent to a concrete subtype specified in this document.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/referenceSystems.xsd', 30, 1))
_Namespace_gml.addCategoryObject('elementBinding', AbstractCRS.name().localName(), AbstractCRS)

TimeInstant = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'TimeInstant'), TimeInstantType, documentation='gml:TimeInstant acts as a zero-dimensional geometric primitive that represents an identifiable position in time.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporal.xsd', 109, 1))
_Namespace_gml.addCategoryObject('elementBinding', TimeInstant.name().localName(), TimeInstant)

TimePeriod = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'TimePeriod'), TimePeriodType, documentation='gml:TimePeriod acts as a one-dimensional geometric primitive that represents an identifiable extent in time.\nThe location in of a gml:TimePeriod is described by the temporal positions of the instants at which it begins and ends. The length of the period is equal to the temporal distance between the two bounding temporal positions. \nBoth beginning and end may be described in terms of their direct position using gml:TimePositionType which is an XML Schema simple content type, or by reference to an indentifiable time instant using gml:TimeInstantPropertyType.\nAlternatively a limit of a gml:TimePeriod may use the conventional GML property model to make a reference to a time instant described elsewhere, or a limit may be indicated as a direct position.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporal.xsd', 133, 1))
_Namespace_gml.addCategoryObject('elementBinding', TimePeriod.name().localName(), TimePeriod)

TimeCoordinateSystem = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'TimeCoordinateSystem'), TimeCoordinateSystemType, documentation='A temporal coordinate system shall be based on a continuous interval scale defined in terms of a single time interval.\nThe differences to ISO 19108 TM_CoordinateSystem are:\n-\tthe origin is specified either using the property gml:originPosition whose value is a direct time position, or using the property gml:origin whose model is gml:TimeInstantPropertyType; this permits more flexibility in representation and also supports referring to a value fixed elsewhere;\n-\tthe interval uses gml:TimeIntervalLengthType.\n', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporalReferenceSystems.xsd', 31, 1))
_Namespace_gml.addCategoryObject('elementBinding', TimeCoordinateSystem.name().localName(), TimeCoordinateSystem)

TimeCalendar = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'TimeCalendar'), TimeCalendarType, documentation='A calendar is a discrete temporal reference system that provides a basis for defining temporal position to a resolution of one day.\ngml:TimeCalendar adds one property to those inherited from gml:TimeReferenceSystem. A gml:referenceFrame provides a link to a gml:TimeCalendarEra that it uses. A  gml:TimeCalendar may reference more than one calendar era. \nThe referenceFrame element follows the standard GML property model, allowing the association to be instantiated either using an inline description using the gml:TimeCalendarEra element, or a link to a gml:TimeCalendarEra which is explicit elsewhere.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporalReferenceSystems.xsd', 53, 1))
_Namespace_gml.addCategoryObject('elementBinding', TimeCalendar.name().localName(), TimeCalendar)

TimeClock = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'TimeClock'), TimeClockType, documentation='A clock provides a basis for defining temporal position within a day. A clock shall be used with a calendar in order to provide a complete description of a temporal position within a specific day.\ngml:TimeClock adds the following properties to those inherited from gml:TimeReferenceSystemType:\n-\tgml:referenceEvent is the name or description of an event, such as solar noon or sunrise, which fixes the position of the base scale of the clock.\n-\tgml:referenceTime specifies the time of day associated with the reference event expressed as a time of day in the given clock. The reference time is usually the origin of the clock scale. \n-\tgml:utcReference specifies the 24 hour local or UTC time that corresponds to the reference time.\n-\tgml:dateBasis contains or references the calendars that use this clock.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporalReferenceSystems.xsd', 110, 1))
_Namespace_gml.addCategoryObject('elementBinding', TimeClock.name().localName(), TimeClock)

TimeOrdinalReferenceSystem = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'TimeOrdinalReferenceSystem'), TimeOrdinalReferenceSystemType, documentation='In some applications of geographic information — such as geology and archaeology — relative position in time is known more precisely than absolute time or duration. The order of events in time can be well established, but the magnitude of the intervals between them cannot be accurately determined; in such cases, the use of an ordinal temporal reference system is appropriate. An ordinal temporal reference system is composed of a sequence of named coterminous eras, which may in turn be composed of sequences of member eras at a finer scale, giving the whole a hierarchical structure of eras of verying resolution. \nAn ordinal temporal reference system whose component eras are not further subdivided is effectively a temporal topological complex constrained to be a linear graph. An ordinal temporal reference system some or all of whose component eras are subdivided is effectively a temporal topological complex with the constraint that parallel branches may only be constructed in pairs where one is a single temporal ordinal era and the other is a sequence of temporal ordinal eras that are called "members" of the "group". This constraint means that within a single temporal ordinal reference system, the relative position of all temporal ordinal eras is unambiguous.  \nThe positions of the beginning and end of a given era may calibrate the relative time scale.\ngml:TimeOrdinalReferenceSystem adds one or more gml:component properties to the generic temporal reference system model.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporalReferenceSystems.xsd', 142, 1))
_Namespace_gml.addCategoryObject('elementBinding', TimeOrdinalReferenceSystem.name().localName(), TimeOrdinalReferenceSystem)

TimeNode = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'TimeNode'), TimeNodeType, documentation='A time node is a zero-dimensional topological primitive that represents an identifiable node in time (it is equivalent to a point in space). A node may act as the termination or initiation of any number of time edges. A time node may be realised as a geometry, its position, whose value is a time instant.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporalTopology.xsd', 67, 1))
_Namespace_gml.addCategoryObject('elementBinding', TimeNode.name().localName(), TimeNode)

TimeEdge = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'TimeEdge'), TimeEdgeType, documentation='A time edge is a one-dimensional topological primitive. It is an open interval that starts and ends at a node. The edge may be realised as a geometry whose value is a time period.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporalTopology.xsd', 93, 1))
_Namespace_gml.addCategoryObject('elementBinding', TimeEdge.name().localName(), TimeEdge)

BaseUnit = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'BaseUnit'), BaseUnitType, documentation='A base unit is a unit of measure that cannot be derived by combination of other base units within a particular system of units.  For example, in the SI system of units, the base units are metre, kilogram, second, Ampere, Kelvin, mole, and candela, for the physical quantity types length, mass, time interval, electric current, thermodynamic temperature, amount of substance and luminous intensity, respectively.\ngml:BaseUnit extends generic gml:UnitDefinition with the property gml:unitsSystem, which carries a reference to the units system to which this base unit is asserted to belong.  ', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/units.xsd', 65, 1))
_Namespace_gml.addCategoryObject('elementBinding', BaseUnit.name().localName(), BaseUnit)

DerivedUnit = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'DerivedUnit'), DerivedUnitType, documentation='Derived units are defined by combination of other units.  Derived units are used for quantities other than those corresponding to the base units, such as hertz (s-1) for frequency, Newton (kg.m/s2) for force.  Derived units based directly on base units are usually preferred for quantities other than the fundamental quantities within a system. If a derived unit is not the preferred unit, the gml:ConventionalUnit element should be used instead.\nThe gml:DerivedUnit extends gml:UnitDefinition with the property gml:derivationUnitTerms.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/units.xsd', 80, 1))
_Namespace_gml.addCategoryObject('elementBinding', DerivedUnit.name().localName(), DerivedUnit)

ConventionalUnit = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'ConventionalUnit'), ConventionalUnitType, documentation='Conventional units that are neither base units nor defined by direct combination of base units are used in many application domains.  For example electronVolt for energy, feet and nautical miles for length.  In most cases there is a known, usually linear, conversion to a preferred unit which is either a base unit or derived by direct combination of base units.\nThe gml:ConventionalUnit extends gml:UnitDefinition with a property that describes a conversion to a preferred unit for this physical quantity.  When the conversion is exact, the element gml:conversionToPreferredUnit should be used, or when the conversion is not exact the element gml:roughConversionToPreferredUnit is available. Both of these elements have the same content model.  The gml:derivationUnitTerm property defined above is included to allow a user to optionally record how this unit may be derived from other ("more primitive") units.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/units.xsd', 108, 1))
_Namespace_gml.addCategoryObject('elementBinding', ConventionalUnit.name().localName(), ConventionalUnit)

CategoryExtent = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'CategoryExtent'), CategoryExtentType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/valueObjects.xsd', 159, 1))
_Namespace_gml.addCategoryObject('elementBinding', CategoryExtent.name().localName(), CategoryExtent)

QuantityExtent = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'QuantityExtent'), QuantityExtentType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/valueObjects.xsd', 173, 1))
_Namespace_gml.addCategoryObject('elementBinding', QuantityExtent.name().localName(), QuantityExtent)

AbstractGeneralConversion = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractGeneralConversion'), AbstractGeneralConversionType, abstract=pyxb.binding.datatypes.boolean(1), documentation='gm:AbstractGeneralConversion is an abstract operation on coordinates that does not include any change of datum. The best-known example of a coordinate conversion is a map projection. The parameters describing coordinate conversions are defined rather than empirically derived. Note that some conversions have no parameters. The operationVersion, sourceCRS, and targetCRS elements are omitted in a coordinate conversion.\nThis abstract complex type is expected to be extended for well-known operation methods with many Conversion instances, in GML Application Schemas that define operation-method-specialized element names and contents. This conversion uses an operation method, usually with associated parameter values. However, operation methods and parameter values are directly associated with concrete subtypes, not with this abstract type. All concrete types derived from this type shall extend this type to include a "usesMethod" element that references the "OperationMethod" element. Similarly, all concrete types derived from this type shall extend this type to include zero or more elements each named "uses...Value" that each use the type of an element substitutable for the "AbstractGeneralParameterValue" element.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 92, 1))
_Namespace_gml.addCategoryObject('elementBinding', AbstractGeneralConversion.name().localName(), AbstractGeneralConversion)

AbstractGeneralTransformation = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractGeneralTransformation'), AbstractGeneralTransformationType, abstract=pyxb.binding.datatypes.boolean(1), documentation='gml:AbstractGeneralTransformation is an abstract operation on coordinates that usually includes a change of Datum. The parameters of a coordinate transformation are empirically derived from data containing the coordinates of a series of points in both coordinate reference systems. This computational process is usually "over-determined", allowing derivation of error (or accuracy) estimates for the transformation. Also, the stochastic nature of the parameters may result in multiple (different) versions of the same coordinate transformation. The operationVersion, sourceCRS, and targetCRS proeprty elements are mandatory in a coordinate transformation.\nThis abstract complex type is expected to be extended for well-known operation methods with many Transformation instances, in Application Schemas that define operation-method-specialized value element names and contents. This transformation uses an operation method with associated parameter values. However, operation methods and parameter values are directly associated with concrete subtypes, not with this abstract type. All concrete types derived from this type shall extend this type to include a "usesMethod" element that references one "OperationMethod" element. Similarly, all concrete types derived from this type shall extend this type to include one or more elements each named "uses...Value" that each use the type of an element substitutable for the "AbstractGeneralParameterValue" element.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 125, 1))
_Namespace_gml.addCategoryObject('elementBinding', AbstractGeneralTransformation.name().localName(), AbstractGeneralTransformation)

ConcatenatedOperation = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'ConcatenatedOperation'), ConcatenatedOperationType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 161, 1))
_Namespace_gml.addCategoryObject('elementBinding', ConcatenatedOperation.name().localName(), ConcatenatedOperation)

PassThroughOperation = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'PassThroughOperation'), PassThroughOperationType, documentation='gml:PassThroughOperation is a pass-through operation specifies that a subset of a coordinate tuple is subject to a specific coordinate operation.\nThe modifiedCoordinate property elements are an ordered sequence of positive integers defining the positions in a coordinate tuple of the coordinates affected by this pass-through operation. The AggregationAttributeGroup should be used to specify that the modifiedCoordinate elements are ordered.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 190, 1))
_Namespace_gml.addCategoryObject('elementBinding', PassThroughOperation.name().localName(), PassThroughOperation)

OperationParameter = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'OperationParameter'), OperationParameterType, documentation='gml:OperationParameter is the definition of a parameter used by an operation method. Most parameter values are numeric, but other types of parameter values are possible. This complex type is expected to be used or extended for all operation methods, without defining operation-method-specialized element names.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 474, 1))
_Namespace_gml.addCategoryObject('elementBinding', OperationParameter.name().localName(), OperationParameter)

OperationParameterGroup = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'OperationParameterGroup'), OperationParameterGroupType, documentation='gml:OperationParameterGroup is the definition of a group of parameters used by an operation method. This complex type is expected to be used or extended for all applicable operation methods, without defining operation-method-specialized element names.\nThe generalOperationParameter elements are an unordered list of associations to the set of operation parameters that are members of this group.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 495, 1))
_Namespace_gml.addCategoryObject('elementBinding', OperationParameterGroup.name().localName(), OperationParameterGroup)

AbstractGeneralDerivedCRS = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractGeneralDerivedCRS'), AbstractGeneralDerivedCRSType, abstract=pyxb.binding.datatypes.boolean(1), documentation='gml:AbstractGeneralDerivedCRS is a coordinate reference system that is defined by its coordinate conversion from another coordinate reference system. This abstract complex type shall not be used, extended, or restricted, in a GML Application Schema, to define a concrete subtype with a meaning equivalent to a concrete subtype specified in this document.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateReferenceSystems.xsd', 32, 1))
_Namespace_gml.addCategoryObject('elementBinding', AbstractGeneralDerivedCRS.name().localName(), AbstractGeneralDerivedCRS)

CompoundCRS = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'CompoundCRS'), CompoundCRSType, documentation='gml:CompundCRS is a coordinate reference system describing the position of points through two or more independent coordinate reference systems. It is associated with a non-repeating sequence of two or more instances of SingleCRS.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateReferenceSystems.xsd', 51, 1))
_Namespace_gml.addCategoryObject('elementBinding', CompoundCRS.name().localName(), CompoundCRS)

GeodeticCRS = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'GeodeticCRS'), GeodeticCRSType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateReferenceSystems.xsd', 80, 1))
_Namespace_gml.addCategoryObject('elementBinding', GeodeticCRS.name().localName(), GeodeticCRS)

VerticalCRS = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'VerticalCRS'), VerticalCRSType, documentation='gml:VerticalCRS is a 1D coordinate reference system used for recording heights or depths. Vertical CRSs make use of the direction of gravity to define the concept of height or depth, but the relationship with gravity may not be straightforward. By implication, ellipsoidal heights (h) cannot be captured in a vertical coordinate reference system. Ellipsoidal heights cannot exist independently, but only as an inseparable part of a 3D coordinate tuple defined in a geographic 3D coordinate reference system.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateReferenceSystems.xsd', 128, 1))
_Namespace_gml.addCategoryObject('elementBinding', VerticalCRS.name().localName(), VerticalCRS)

EngineeringCRS = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'EngineeringCRS'), EngineeringCRSType, documentation='gml:EngineeringCRS is a contextually local coordinate reference system which can be divided into two broad categories:\n-\tearth-fixed systems applied to engineering activities on or near the surface of the earth;\n-\tCRSs on moving platforms such as road vehicles, vessels, aircraft, or spacecraft, see ISO 19111 8.3.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateReferenceSystems.xsd', 234, 1))
_Namespace_gml.addCategoryObject('elementBinding', EngineeringCRS.name().localName(), EngineeringCRS)

ImageCRS = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'ImageCRS'), ImageCRSType, documentation='gml:ImageCRS is an engineering coordinate reference system applied to locations in images. Image coordinate reference systems are treated as a separate sub-type because the definition of the associated image datum contains two attributes not relevant to other engineering datums.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateReferenceSystems.xsd', 298, 1))
_Namespace_gml.addCategoryObject('elementBinding', ImageCRS.name().localName(), ImageCRS)

TemporalCRS = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'TemporalCRS'), TemporalCRSType, documentation='gml:TemporalCRS is a 1D coordinate reference system used for the recording of time.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateReferenceSystems.xsd', 336, 1))
_Namespace_gml.addCategoryObject('elementBinding', TemporalCRS.name().localName(), TemporalCRS)

EllipsoidalCS = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'EllipsoidalCS'), EllipsoidalCSType, documentation='gml:EllipsoidalCS is a two- or three-dimensional coordinate system in which position is specified by geodetic latitude, geodetic longitude, and (in the three-dimensional case) ellipsoidal height. An EllipsoidalCS shall have two or three gml:axis property elements; the number of associations shall equal the dimension of the CS.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateSystems.xsd', 107, 1))
_Namespace_gml.addCategoryObject('elementBinding', EllipsoidalCS.name().localName(), EllipsoidalCS)

CartesianCS = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'CartesianCS'), CartesianCSType, documentation='gml:CartesianCS is a 1-, 2-, or 3-dimensional coordinate system. In the 1-dimensional case, it contains a single straight coordinate axis. In the 2- and 3-dimensional cases gives the position of points relative to orthogonal straight axes. In the multi-dimensional case, all axes shall have the same length unit of measure. A CartesianCS shall have one, two, or three gml:axis property elements.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateSystems.xsd', 126, 1))
_Namespace_gml.addCategoryObject('elementBinding', CartesianCS.name().localName(), CartesianCS)

VerticalCS = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'VerticalCS'), VerticalCSType, documentation="gml:VerticalCS is a one-dimensional coordinate system used to record the heights or depths of points. Such a coordinate system is usually dependent on the Earth's gravity field, perhaps loosely as when atmospheric pressure is the basis for the vertical coordinate system axis. A VerticalCS shall have one gml:axis property element.", location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateSystems.xsd', 145, 1))
_Namespace_gml.addCategoryObject('elementBinding', VerticalCS.name().localName(), VerticalCS)

TimeCS = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'TimeCS'), TimeCSType, documentation='gml:TimeCS is a one-dimensional coordinate system containing a time axis, used to describe the temporal position of a point in the specified time units from a specified time origin. A TimeCS shall have one gml:axis property element.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateSystems.xsd', 164, 1))
_Namespace_gml.addCategoryObject('elementBinding', TimeCS.name().localName(), TimeCS)

LinearCS = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'LinearCS'), LinearCSType, documentation='gml:LinearCS is a one-dimensional coordinate system that consists of the points that lie on the single axis described. The associated coordinate is the distance – with or without offset – from the specified datum to the point along the axis. A LinearCS shall have one gml:axis property element.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateSystems.xsd', 183, 1))
_Namespace_gml.addCategoryObject('elementBinding', LinearCS.name().localName(), LinearCS)

UserDefinedCS = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'UserDefinedCS'), UserDefinedCSType, documentation='gml:UserDefinedCS is a two- or three-dimensional coordinate system that consists of any combination of coordinate axes not covered by any other coordinate system type. A UserDefinedCS shall have two or three gml:axis property elements; the number of property elements shall equal the dimension of the CS.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateSystems.xsd', 202, 1))
_Namespace_gml.addCategoryObject('elementBinding', UserDefinedCS.name().localName(), UserDefinedCS)

SphericalCS = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'SphericalCS'), SphericalCSType, documentation='gml:SphericalCS is a three-dimensional coordinate system with one distance measured from the origin and two angular coordinates. A SphericalCS shall have three gml:axis property elements.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateSystems.xsd', 221, 1))
_Namespace_gml.addCategoryObject('elementBinding', SphericalCS.name().localName(), SphericalCS)

PolarCS = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'PolarCS'), PolarCSType, documentation='gml:PolarCS ia s two-dimensional coordinate system in which position is specified by the distance from the origin and the angle between the line from the origin to a point and a reference direction. A PolarCS shall have two gml:axis property elements.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateSystems.xsd', 240, 1))
_Namespace_gml.addCategoryObject('elementBinding', PolarCS.name().localName(), PolarCS)

CylindricalCS = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'CylindricalCS'), CylindricalCSType, documentation='gml:CylindricalCS is a three-dimensional coordinate system consisting of a polar coordinate system extended by a straight coordinate axis perpendicular to the plane spanned by the polar coordinate system. A CylindricalCS shall have three gml:axis property elements.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateSystems.xsd', 259, 1))
_Namespace_gml.addCategoryObject('elementBinding', CylindricalCS.name().localName(), CylindricalCS)

AffineCS = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'AffineCS'), AffineCSType, documentation='gml:AffineCS is a two- or three-dimensional coordinate system with straight axes that are not necessarily orthogonal. An AffineCS shall have two or three gml:axis property elements; the number of property elements shall equal the dimension of the CS.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateSystems.xsd', 278, 1))
_Namespace_gml.addCategoryObject('elementBinding', AffineCS.name().localName(), AffineCS)

GeodeticDatum = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'GeodeticDatum'), GeodeticDatumType, documentation='gml:GeodeticDatum is a geodetic datum defines the precise location and orientation in 3-dimensional space of a defined ellipsoid (or sphere), or of a Cartesian coordinate system centered in this ellipsoid (or sphere).', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/datums.xsd', 61, 1))
_Namespace_gml.addCategoryObject('elementBinding', GeodeticDatum.name().localName(), GeodeticDatum)

EngineeringDatum = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'EngineeringDatum'), EngineeringDatumType, documentation='gml:EngineeringDatum defines the origin of an engineering coordinate reference system, and is used in a region around that origin. This origin may be fixed with respect to the earth (such as a defined point at a construction site), or be a defined point on a moving vehicle (such as on a ship or satellite).', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/datums.xsd', 173, 1))
_Namespace_gml.addCategoryObject('elementBinding', EngineeringDatum.name().localName(), EngineeringDatum)

ImageDatum = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'ImageDatum'), ImageDatumType, documentation='gml:ImageDatum defines the origin of an image coordinate reference system, and is used in a local context only. For an image datum, the anchor definition is usually either the centre of the image or the corner of the image. For more information, see ISO 19111 B.3.5.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/datums.xsd', 192, 1))
_Namespace_gml.addCategoryObject('elementBinding', ImageDatum.name().localName(), ImageDatum)

VerticalDatum = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'VerticalDatum'), VerticalDatumType, documentation='gml:VerticalDatum is a textual description and/or a set of parameters identifying a particular reference level surface used as a zero-height surface, including its position with respect to the Earth for any of the height types recognized by this International Standard.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/datums.xsd', 220, 1))
_Namespace_gml.addCategoryObject('elementBinding', VerticalDatum.name().localName(), VerticalDatum)

TemporalCS = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'TemporalCS'), TemporalCSType, documentation='', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 247, 1))
_Namespace_gml.addCategoryObject('elementBinding', TemporalCS.name().localName(), TemporalCS)

ObliqueCartesianCS = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'ObliqueCartesianCS'), ObliqueCartesianCSType, documentation='', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 299, 1))
_Namespace_gml.addCategoryObject('elementBinding', ObliqueCartesianCS.name().localName(), ObliqueCartesianCS)

GeographicCRS = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'GeographicCRS'), GeographicCRSType, documentation='', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 451, 1))
_Namespace_gml.addCategoryObject('elementBinding', GeographicCRS.name().localName(), GeographicCRS)

GeocentricCRS = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'GeocentricCRS'), GeocentricCRSType, documentation='', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 483, 1))
_Namespace_gml.addCategoryObject('elementBinding', GeocentricCRS.name().localName(), GeocentricCRS)

LinearRing = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'LinearRing'), LinearRingType, documentation='A LinearRing is defined by four or more coordinate tuples, with linear interpolation between them; the first and last coordinates shall be coincident. The number of direct positions in the list shall be at least four.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic2d.xsd', 115, 1))
_Namespace_gml.addCategoryObject('elementBinding', LinearRing.name().localName(), LinearRing)

Ring = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'Ring'), RingType, documentation='A ring is used to represent a single connected component of a surface boundary as specified in ISO 19107:2003, 6.3.6.\nEvery gml:curveMember references or contains one curve, i.e. any element which is substitutable for gml:AbstractCurve. In the context of a ring, the curves describe the boundary of the surface. The sequence of curves shall be contiguous and connected in a cycle.\nIf provided, the aggregationType attribute shall have the value "sequence".', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 632, 1))
_Namespace_gml.addCategoryObject('elementBinding', Ring.name().localName(), Ring)

Tin = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'Tin'), TinType, documentation='A tin is a triangulated surface that uses the Delauny algorithm or a similar algorithm complemented with consideration of stoplines (stopLines), breaklines (breakLines), and maximum length of triangle sides (maxLength). controlPoint shall contain a set of the positions (three or more) used as posts for this TIN (corners of the triangles in the TIN). See ISO 19107:2003, 6.4.39 for details.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 754, 1))
_Namespace_gml.addCategoryObject('elementBinding', Tin.name().localName(), Tin)

Conversion = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'Conversion'), ConversionType, documentation='gml:Conversion is a concrete operation on coordinates that does not include any change of Datum. The best-known example of a coordinate conversion is a map projection. The parameters describing coordinate conversions are defined rather than empirically derived. Note that some conversions have no parameters.\nThis concrete complex type can be used without using a GML Application Schema that defines operation-method-specialized element names and contents, especially for methods with only one Conversion instance.\nThe usesValue property elements are an unordered list of composition associations to the set of parameter values used by this conversion operation.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 221, 1))
_Namespace_gml.addCategoryObject('elementBinding', Conversion.name().localName(), Conversion)

Transformation = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'Transformation'), TransformationType, documentation='gml:Transformation is a concrete object element derived from gml:GeneralTransformation (13.6.2.13).\nThis concrete object can be used for all operation methods, without using a GML Application Schema that defines operation-method-specialized element names and contents, especially for methods with only one Transformation instance.\nThe parameterValue elements are an unordered list of composition associations to the set of parameter values used by this conversion operation.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 257, 1))
_Namespace_gml.addCategoryObject('elementBinding', Transformation.name().localName(), Transformation)

ProjectedCRS = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'ProjectedCRS'), ProjectedCRSType, documentation='gml:ProjectedCRS is a 2D coordinate reference system used to approximate the shape of the earth on a planar surface, but in such a way that the distortion that is inherent to the approximation is carefully controlled and known. Distortion correction is commonly applied to calculated bearings and distances to produce values that are a close match to actual field values.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateReferenceSystems.xsd', 162, 1))
_Namespace_gml.addCategoryObject('elementBinding', ProjectedCRS.name().localName(), ProjectedCRS)

DerivedCRS = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'DerivedCRS'), DerivedCRSType, documentation='gml:DerivedCRS is a single coordinate reference system that is defined by its coordinate conversion from another single coordinate reference system known as the base CRS. The base CRS can be a projected coordinate reference system, if this DerivedCRS is used for a georectified grid coverage as described in ISO 19123, Clause 8.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateReferenceSystems.xsd', 194, 1))
_Namespace_gml.addCategoryObject('elementBinding', DerivedCRS.name().localName(), DerivedCRS)

TemporalDatum = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'TemporalDatum'), TemporalDatumType, documentation='A gml:TemporalDatum defines the origin of a Temporal Reference System. This type omits the "anchorDefinition" and "realizationEpoch" elements and adds the "origin" element with the dateTime type.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/datums.xsd', 239, 1))
_Namespace_gml.addCategoryObject('elementBinding', TemporalDatum.name().localName(), TemporalDatum)



PT_LocaleContainer_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'description'), CharacterString_PropertyType, scope=PT_LocaleContainer_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/freeText.xsd', 81, 3)))

PT_LocaleContainer_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'locale'), PT_Locale_PropertyType, scope=PT_LocaleContainer_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/freeText.xsd', 82, 3)))

PT_LocaleContainer_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'date'), CI_Date_PropertyType, scope=PT_LocaleContainer_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/freeText.xsd', 83, 3)))

PT_LocaleContainer_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'responsibleParty'), CI_ResponsibleParty_PropertyType, scope=PT_LocaleContainer_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/freeText.xsd', 84, 3)))

PT_LocaleContainer_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'localisedString'), LocalisedCharacterString_PropertyType, scope=PT_LocaleContainer_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/freeText.xsd', 85, 3)))

def _BuildAutomaton ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton
    del _BuildAutomaton
    import pyxb.utils.fac as fac

    counters = set()
    states = []
    final_update = None
    symbol = pyxb.binding.content.ElementUse(PT_LocaleContainer_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'description')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/freeText.xsd', 81, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(PT_LocaleContainer_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'locale')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/freeText.xsd', 82, 3))
    st_1 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(PT_LocaleContainer_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'date')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/freeText.xsd', 83, 3))
    st_2 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(PT_LocaleContainer_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'responsibleParty')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/freeText.xsd', 84, 3))
    st_3 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_3)
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(PT_LocaleContainer_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'localisedString')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/freeText.xsd', 85, 3))
    st_4 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_4)
    transitions = []
    transitions.append(fac.Transition(st_1, [
         ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_2, [
         ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_2, [
         ]))
    transitions.append(fac.Transition(st_3, [
         ]))
    st_2._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_3, [
         ]))
    transitions.append(fac.Transition(st_4, [
         ]))
    st_3._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
         ]))
    st_4._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
PT_LocaleContainer_Type._Automaton = _BuildAutomaton()




MD_Resolution_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'equivalentScale'), MD_RepresentativeFraction_PropertyType, scope=MD_Resolution_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 239, 3)))

MD_Resolution_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'distance'), Distance_PropertyType, scope=MD_Resolution_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 240, 3)))

def _BuildAutomaton_ ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_
    del _BuildAutomaton_
    import pyxb.utils.fac as fac

    counters = set()
    states = []
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(MD_Resolution_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'equivalentScale')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 239, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(MD_Resolution_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'distance')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 240, 3))
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    transitions = []
    st_0._set_transitionSet(transitions)
    transitions = []
    st_1._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
MD_Resolution_Type._Automaton = _BuildAutomaton_()




MD_ScopeDescription_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'attributes'), ObjectReference_PropertyType, scope=MD_ScopeDescription_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/maintenance.xsd', 49, 3)))

MD_ScopeDescription_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'features'), ObjectReference_PropertyType, scope=MD_ScopeDescription_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/maintenance.xsd', 50, 3)))

MD_ScopeDescription_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'featureInstances'), ObjectReference_PropertyType, scope=MD_ScopeDescription_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/maintenance.xsd', 51, 3)))

MD_ScopeDescription_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'attributeInstances'), ObjectReference_PropertyType, scope=MD_ScopeDescription_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/maintenance.xsd', 52, 3)))

MD_ScopeDescription_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'dataset'), CharacterString_PropertyType, scope=MD_ScopeDescription_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/maintenance.xsd', 53, 3)))

MD_ScopeDescription_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'other'), CharacterString_PropertyType, scope=MD_ScopeDescription_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/maintenance.xsd', 54, 3)))

def _BuildAutomaton_2 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_2
    del _BuildAutomaton_2
    import pyxb.utils.fac as fac

    counters = set()
    states = []
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(MD_ScopeDescription_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'attributes')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/maintenance.xsd', 49, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(MD_ScopeDescription_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'features')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/maintenance.xsd', 50, 3))
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(MD_ScopeDescription_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'featureInstances')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/maintenance.xsd', 51, 3))
    st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(MD_ScopeDescription_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'attributeInstances')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/maintenance.xsd', 52, 3))
    st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_3)
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(MD_ScopeDescription_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'dataset')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/maintenance.xsd', 53, 3))
    st_4 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_4)
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(MD_ScopeDescription_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'other')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/maintenance.xsd', 54, 3))
    st_5 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_5)
    transitions = []
    transitions.append(fac.Transition(st_0, [
         ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_1, [
         ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_2, [
         ]))
    st_2._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_3, [
         ]))
    st_3._set_transitionSet(transitions)
    transitions = []
    st_4._set_transitionSet(transitions)
    transitions = []
    st_5._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
MD_ScopeDescription_Type._Automaton = _BuildAutomaton_2()




AbstractGeneralParameterValuePropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractGeneralParameterValue'), AbstractGeneralParameterValueType, abstract=pyxb.binding.datatypes.boolean(1), scope=AbstractGeneralParameterValuePropertyType, documentation='gml:AbstractGeneralParameterValue is an abstract parameter value or group of parameter values.\nThis abstract complexType is expected to be extended and restricted for well-known operation methods with many instances, in Application Schemas that define operation-method-specialized element names and contents. Specific parameter value elements are directly contained in concrete subtypes, not in this abstract type. All concrete types derived from this type shall extend this type to include one "...Value" element with an appropriate type, which should be one of the element types allowed in the ParameterValueType. In addition, all derived concrete types shall extend this type to include a "operationParameter" property element that references one element substitutable for the "OperationParameter" object element.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 283, 1)))

def _BuildAutomaton_3 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_3
    del _BuildAutomaton_3
    import pyxb.utils.fac as fac

    counters = set()
    states = []
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(AbstractGeneralParameterValuePropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractGeneralParameterValue')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 297, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
AbstractGeneralParameterValuePropertyType._Automaton = _BuildAutomaton_3()




RangeSetType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'DataBlock'), DataBlockType, scope=RangeSetType, documentation='gml:DataBlock describes the Range as a block of text encoded values similar to a Common Separated Value (CSV) representation.\nThe range set parameterization is described by the property gml:rangeParameters.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coverage.xsd', 103, 1)))

RangeSetType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'File'), FileType, scope=RangeSetType, documentation='for efficiency reasons, GML also provides a means of encoding the range set in an arbitrary external encoding, such as a binary file.  This encoding may be "well-known" but this is not required. This mode uses the gml:File element.\nThe values of the coverage (attribute values in the range set) are transmitted in a external file that is referenced from the XML structure described by gml:FileType.  The external file is referenced by the gml:fileReference property that is an anyURI (the gml:fileName property has been deprecated).  This means that the external file may be located remotely from the referencing GML instance. \nThe gml:compression property points to a definition of a compression algorithm through an anyURI.  This may be a retrievable, computable definition or simply a reference to an unambiguous name for the compression method.\nThe gml:mimeType property points to a definition of the file mime type.\nThe gml:fileStructure property is defined by a codelist. Note further that all values shall be enclosed in a single file. Multi-file structures for values are not supported in GML.\nThe semantics of the range set is described as above using the gml:rangeParameters property.\nNote that if any compression algorithm is applied, the structure above applies only to the pre-compression or post-decompression structure of the file.\nNote that the fields within a record match the gml:valueComponents of the gml:CompositeValue in document order.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coverage.xsd', 130, 1)))

RangeSetType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractScalarValueList'), pyxb.binding.datatypes.anyType, abstract=pyxb.binding.datatypes.boolean(1), scope=RangeSetType, documentation='gml:AbstractScalarValueList is an abstract element which acts as the head of a substitution group which contains gml:BooleanList, gml:CategoryList, gml:CountList and gml:QuantityList, and (transitively) the elements in their substitution groups.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/valueObjects.xsd', 81, 1)))

RangeSetType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'ValueArray'), ValueArrayType, scope=RangeSetType, documentation='A Value Array is used for homogeneous arrays of primitive and aggregate values.  \nThe member values may be scalars, composites, arrays or lists.\nValueArray has the same content model as CompositeValue, but the member values shall be homogeneous.  The element declaration contains a Schematron constraint which expresses this restriction precisely.  Since the members are homogeneous, the gml:referenceSystem (uom, codeSpace) may be specified on the gml:ValueArray itself and inherited by all the members if desired.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/valueObjects.xsd', 141, 1)))

def _BuildAutomaton_4 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_4
    del _BuildAutomaton_4
    import pyxb.utils.fac as fac

    counters = set()
    states = []
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(RangeSetType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'ValueArray')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coverage.xsd', 97, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(RangeSetType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractScalarValueList')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coverage.xsd', 98, 3))
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(RangeSetType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'DataBlock')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coverage.xsd', 99, 3))
    st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(RangeSetType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'File')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coverage.xsd', 100, 3))
    st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_3)
    transitions = []
    transitions.append(fac.Transition(st_0, [
         ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_1, [
         ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    st_2._set_transitionSet(transitions)
    transitions = []
    st_3._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
RangeSetType._Automaton = _BuildAutomaton_4()




DataBlockType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'rangeParameters'), AssociationRoleType, scope=DataBlockType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coverage.xsd', 118, 1)))

DataBlockType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'tupleList'), CoordinatesType, scope=DataBlockType, documentation='gml:CoordinatesType consists of a list of coordinate tuples, with each coordinate tuple separated by the ts or tuple separator (whitespace), and each coordinate in the tuple by the cs or coordinate separator (comma).\nThe gml:tupleList encoding is effectively "band-interleaved".', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coverage.xsd', 119, 1)))

DataBlockType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'doubleOrNilReasonTupleList'), doubleOrNilReasonList, scope=DataBlockType, documentation='gml:doubleOrNilReasonList consists of a list of gml:doubleOrNilReason values, each separated by a whitespace. The gml:doubleOrNilReason values are grouped into tuples where the dimension of each tuple in the list is equal to the number of range parameters.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coverage.xsd', 125, 1)))

def _BuildAutomaton_5 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_5
    del _BuildAutomaton_5
    import pyxb.utils.fac as fac

    counters = set()
    states = []
    final_update = None
    symbol = pyxb.binding.content.ElementUse(DataBlockType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'rangeParameters')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coverage.xsd', 111, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(DataBlockType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'tupleList')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coverage.xsd', 113, 4))
    st_1 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(DataBlockType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'doubleOrNilReasonTupleList')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coverage.xsd', 114, 4))
    st_2 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    transitions = []
    transitions.append(fac.Transition(st_1, [
         ]))
    transitions.append(fac.Transition(st_2, [
         ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    st_1._set_transitionSet(transitions)
    transitions = []
    st_2._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
DataBlockType._Automaton = _BuildAutomaton_5()




FileType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'rangeParameters'), AssociationRoleType, scope=FileType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coverage.xsd', 118, 1)))

FileType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'fileName'), pyxb.binding.datatypes.anyURI, scope=FileType, documentation='', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coverage.xsd', 146, 4)))

FileType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'fileReference'), pyxb.binding.datatypes.anyURI, scope=FileType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coverage.xsd', 151, 4)))

FileType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'fileStructure'), CodeType, scope=FileType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coverage.xsd', 153, 3)))

FileType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'mimeType'), pyxb.binding.datatypes.anyURI, scope=FileType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coverage.xsd', 154, 3)))

FileType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'compression'), pyxb.binding.datatypes.anyURI, scope=FileType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coverage.xsd', 155, 3)))

def _BuildAutomaton_6 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_6
    del _BuildAutomaton_6
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coverage.xsd', 154, 3))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coverage.xsd', 155, 3))
    counters.add(cc_1)
    states = []
    final_update = None
    symbol = pyxb.binding.content.ElementUse(FileType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'rangeParameters')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coverage.xsd', 144, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(FileType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'fileName')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coverage.xsd', 146, 4))
    st_1 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(FileType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'fileReference')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coverage.xsd', 151, 4))
    st_2 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(FileType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'fileStructure')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coverage.xsd', 153, 3))
    st_3 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_3)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(FileType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'mimeType')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coverage.xsd', 154, 3))
    st_4 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_4)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_1, False))
    symbol = pyxb.binding.content.ElementUse(FileType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'compression')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coverage.xsd', 155, 3))
    st_5 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_5)
    transitions = []
    transitions.append(fac.Transition(st_1, [
         ]))
    transitions.append(fac.Transition(st_2, [
         ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_3, [
         ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_3, [
         ]))
    st_2._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
         ]))
    transitions.append(fac.Transition(st_5, [
         ]))
    st_3._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_4._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_1, True) ]))
    st_5._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
FileType._Automaton = _BuildAutomaton_6()




CoverageFunctionType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'CoverageMappingRule'), MappingRuleType, scope=CoverageFunctionType, documentation="gml:CoverageMappingRule provides a formal or informal description of the coverage function.\nThe mapping rule may be defined as an in-line string (gml:ruleDefinition) or via a remote reference through xlink:href (gml:ruleReference).  \nIf no rule name is specified, the default is 'Linear' with respect to members of the domain in document order.", location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coverage.xsd', 172, 1)))

CoverageFunctionType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'GridFunction'), GridFunctionType, scope=CoverageFunctionType, documentation='gml:GridFunction provides an explicit mapping rule for grid geometries, i.e. the domain shall be a geometry of type grid.  It describes the mapping of grid posts (discrete point grid coverage) or grid cells (discrete surface coverage) to the values in the range set.\nThe gml:startPoint is the index position of a point in the grid that is mapped to the first point in the range set (this is also the index position of the first grid post).  If the gml:startPoint property is omitted the gml:startPoint is assumed to be equal to the value of gml:low in the gml:Grid geometry. Subsequent points in the mapping are determined by the value of the gml:sequenceRule.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coverage.xsd', 185, 1)))

CoverageFunctionType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'MappingRule'), StringOrRefType, scope=CoverageFunctionType, documentation='', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 923, 1)))

def _BuildAutomaton_7 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_7
    del _BuildAutomaton_7
    import pyxb.utils.fac as fac

    counters = set()
    states = []
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(CoverageFunctionType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'MappingRule')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coverage.xsd', 167, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(CoverageFunctionType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'CoverageMappingRule')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coverage.xsd', 168, 3))
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(CoverageFunctionType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'GridFunction')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coverage.xsd', 169, 3))
    st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    transitions = []
    st_0._set_transitionSet(transitions)
    transitions = []
    st_1._set_transitionSet(transitions)
    transitions = []
    st_2._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
CoverageFunctionType._Automaton = _BuildAutomaton_7()




MappingRuleType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'ruleDefinition'), pyxb.binding.datatypes.string, scope=MappingRuleType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coverage.xsd', 181, 3)))

MappingRuleType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'ruleReference'), ReferenceType, scope=MappingRuleType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coverage.xsd', 182, 3)))

def _BuildAutomaton_8 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_8
    del _BuildAutomaton_8
    import pyxb.utils.fac as fac

    counters = set()
    states = []
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(MappingRuleType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'ruleDefinition')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coverage.xsd', 181, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(MappingRuleType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'ruleReference')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coverage.xsd', 182, 3))
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    transitions = []
    st_0._set_transitionSet(transitions)
    transitions = []
    st_1._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
MappingRuleType._Automaton = _BuildAutomaton_8()




GridFunctionType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'sequenceRule'), SequenceRuleType, scope=GridFunctionType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coverage.xsd', 193, 3)))

GridFunctionType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'startPoint'), integerList, scope=GridFunctionType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coverage.xsd', 194, 3)))

def _BuildAutomaton_9 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_9
    del _BuildAutomaton_9
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coverage.xsd', 193, 3))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coverage.xsd', 194, 3))
    counters.add(cc_1)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(GridFunctionType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'sequenceRule')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coverage.xsd', 193, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_1, False))
    symbol = pyxb.binding.content.ElementUse(GridFunctionType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'startPoint')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coverage.xsd', 194, 3))
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_1, True) ]))
    st_1._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
GridFunctionType._Automaton = _BuildAutomaton_9()




CTD_ANON._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'SecondDefiningParameter'), CTD_ANON_, scope=CTD_ANON, location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/datums.xsd', 127, 1)))

def _BuildAutomaton_10 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_10
    del _BuildAutomaton_10
    import pyxb.utils.fac as fac

    counters = set()
    states = []
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(CTD_ANON._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'SecondDefiningParameter')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/datums.xsd', 123, 4))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
CTD_ANON._Automaton = _BuildAutomaton_10()




CTD_ANON_._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'inverseFlattening'), MeasureType, scope=CTD_ANON_, location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/datums.xsd', 130, 4)))

CTD_ANON_._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'semiMinorAxis'), LengthType, scope=CTD_ANON_, location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/datums.xsd', 131, 4)))

CTD_ANON_._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'isSphere'), pyxb.binding.datatypes.boolean, scope=CTD_ANON_, location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/datums.xsd', 132, 4), unicode_default='true'))

def _BuildAutomaton_11 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_11
    del _BuildAutomaton_11
    import pyxb.utils.fac as fac

    counters = set()
    states = []
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(CTD_ANON_._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'inverseFlattening')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/datums.xsd', 130, 4))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(CTD_ANON_._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'semiMinorAxis')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/datums.xsd', 131, 4))
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(CTD_ANON_._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'isSphere')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/datums.xsd', 132, 4))
    st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    transitions = []
    st_0._set_transitionSet(transitions)
    transitions = []
    st_1._set_transitionSet(transitions)
    transitions = []
    st_2._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
CTD_ANON_._Automaton = _BuildAutomaton_11()




DMSAngleType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'degrees'), DegreesType, scope=DMSAngleType, documentation='', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 554, 1)))

DMSAngleType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'decimalMinutes'), DecimalMinutesType, scope=DMSAngleType, documentation='', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 588, 1)))

DMSAngleType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'minutes'), ArcMinutesType, scope=DMSAngleType, documentation='', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 602, 1)))

DMSAngleType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'seconds'), ArcSecondsType, scope=DMSAngleType, documentation='', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 615, 1)))

def _BuildAutomaton_12 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_12
    del _BuildAutomaton_12
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 545, 3))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 549, 5))
    counters.add(cc_1)
    states = []
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(DMSAngleType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'degrees')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 544, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(DMSAngleType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'decimalMinutes')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 546, 4))
    st_1 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(DMSAngleType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'minutes')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 548, 5))
    st_2 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    final_update.add(fac.UpdateInstruction(cc_1, False))
    symbol = pyxb.binding.content.ElementUse(DMSAngleType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'seconds')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 549, 5))
    st_3 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_3)
    transitions = []
    transitions.append(fac.Transition(st_1, [
         ]))
    transitions.append(fac.Transition(st_2, [
         ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_3, [
         ]))
    st_2._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, True),
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, True),
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_1, True) ]))
    st_3._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
DMSAngleType._Automaton = _BuildAutomaton_12()




AngleChoiceType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'dmsAngle'), DMSAngleType, scope=AngleChoiceType, documentation='', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 534, 1)))

AngleChoiceType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'angle'), AngleType, scope=AngleChoiceType, documentation='The gml:angle property element is used to record the value of an angle quantity as a single number, with its units.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/measures.xsd', 63, 1)))

def _BuildAutomaton_13 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_13
    del _BuildAutomaton_13
    import pyxb.utils.fac as fac

    counters = set()
    states = []
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(AngleChoiceType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'angle')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 634, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(AngleChoiceType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'dmsAngle')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 635, 3))
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    transitions = []
    st_0._set_transitionSet(transitions)
    transitions = []
    st_1._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
AngleChoiceType._Automaton = _BuildAutomaton_13()




ArrayAssociationType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractObject'), pyxb.binding.datatypes.anyType, abstract=pyxb.binding.datatypes.boolean(1), scope=ArrayAssociationType, documentation='This element has no type defined, and is therefore implicitly (according to the rules of W3C XML Schema) an XML Schema anyType. It is used as the head of an XML Schema substitution group which unifies complex content and certain simple content elements used for datatypes in GML, including the gml:AbstractGML substitution group.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 21, 1)))

def _BuildAutomaton_14 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_14
    del _BuildAutomaton_14
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 653, 3))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(ArrayAssociationType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractObject')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 653, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
ArrayAssociationType._Automaton = _BuildAutomaton_14()




def _BuildAutomaton_15 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_15
    del _BuildAutomaton_15
    import pyxb.utils.fac as fac

    counters = set()
    states = []
    return fac.Automaton(states, counters, True, containing_state=None)
AbstractMetaDataType._Automaton = _BuildAutomaton_15()




FeatureArrayPropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractFeature'), AbstractFeatureType, abstract=pyxb.binding.datatypes.boolean(1), scope=FeatureArrayPropertyType, documentation='This abstract element serves as the head of a substitution group which may contain any elements whose content model is derived from gml:AbstractFeatureType.  This may be used as a variable in the construction of content models.  \ngml:AbstractFeature may be thought of as "anything that is a GML feature" and may be used to define variables or templates in which the value of a GML property is "any feature". This occurs in particular in a GML feature collection where the feature member properties contain one or multiple copies of gml:AbstractFeature respectively.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/feature.xsd', 32, 1)))

def _BuildAutomaton_16 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_16
    del _BuildAutomaton_16
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 819, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(FeatureArrayPropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractFeature')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 820, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
FeatureArrayPropertyType._Automaton = _BuildAutomaton_16()




IndirectEntryType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'DefinitionProxy'), DefinitionProxyType, scope=IndirectEntryType, documentation='', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 901, 1)))

def _BuildAutomaton_17 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_17
    del _BuildAutomaton_17
    import pyxb.utils.fac as fac

    counters = set()
    states = []
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(IndirectEntryType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'DefinitionProxy')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 898, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
IndirectEntryType._Automaton = _BuildAutomaton_17()




DirectionVectorType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'horizontalAngle'), AngleType, scope=DirectionVectorType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/direction.xsd', 41, 4)))

DirectionVectorType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'verticalAngle'), AngleType, scope=DirectionVectorType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/direction.xsd', 42, 4)))

DirectionVectorType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'vector'), VectorType, scope=DirectionVectorType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic0d1d.xsd', 132, 1)))

def _BuildAutomaton_18 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_18
    del _BuildAutomaton_18
    import pyxb.utils.fac as fac

    counters = set()
    states = []
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(DirectionVectorType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'vector')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/direction.xsd', 36, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(DirectionVectorType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'horizontalAngle')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/direction.xsd', 41, 4))
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(DirectionVectorType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'verticalAngle')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/direction.xsd', 42, 4))
    st_2 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    transitions = []
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_2, [
         ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    st_2._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
DirectionVectorType._Automaton = _BuildAutomaton_18()




DirectionDescriptionType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'compassPoint'), CompassPointEnumeration, scope=DirectionDescriptionType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/direction.xsd', 55, 3)))

DirectionDescriptionType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'keyword'), CodeType, scope=DirectionDescriptionType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/direction.xsd', 56, 3)))

DirectionDescriptionType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'description'), pyxb.binding.datatypes.string, scope=DirectionDescriptionType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/direction.xsd', 57, 3)))

DirectionDescriptionType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'reference'), ReferenceType, scope=DirectionDescriptionType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/direction.xsd', 58, 3)))

def _BuildAutomaton_19 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_19
    del _BuildAutomaton_19
    import pyxb.utils.fac as fac

    counters = set()
    states = []
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(DirectionDescriptionType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'compassPoint')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/direction.xsd', 55, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(DirectionDescriptionType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'keyword')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/direction.xsd', 56, 3))
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(DirectionDescriptionType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'description')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/direction.xsd', 57, 3))
    st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(DirectionDescriptionType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'reference')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/direction.xsd', 58, 3))
    st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_3)
    transitions = []
    st_0._set_transitionSet(transitions)
    transitions = []
    st_1._set_transitionSet(transitions)
    transitions = []
    st_2._set_transitionSet(transitions)
    transitions = []
    st_3._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
DirectionDescriptionType._Automaton = _BuildAutomaton_19()




HistoryPropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractTimeSlice'), AbstractTimeSliceType, abstract=pyxb.binding.datatypes.boolean(1), scope=HistoryPropertyType, documentation='To describe an event — an action that occurs at an instant or over an interval of time — GML provides the gml:AbtractTimeSlice element. A timeslice encapsulates the time-varying properties of a dynamic feature -- it shall be extended to represent a time stamped projection of a specific feature. The gml:dataSource property describes how the temporal data was acquired.\nA gml:AbstractTimeSlice instance is a GML object that encapsulates updates of the dynamic—or volatile—properties that reflect some change event; it thus includes only those feature properties that have actually changed due to some process.\ngml:AbstractTimeSlice basically provides a facility for attribute-level time stamping, in contrast to the object-level time stamping of dynamic feature instances. \nThe time slice can thus be viewed as event or process-oriented, whereas a snapshot is more state or structure-oriented. A timeslice has richer causality, whereas a snapshot merely portrays the status of the whole. \n', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dynamicFeature.xsd', 78, 1)))

def _BuildAutomaton_20 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_20
    del _BuildAutomaton_20
    import pyxb.utils.fac as fac

    counters = set()
    states = []
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(HistoryPropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractTimeSlice')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dynamicFeature.xsd', 105, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
         ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
HistoryPropertyType._Automaton = _BuildAutomaton_20()




GeometryArrayPropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractGeometry'), AbstractGeometryType, abstract=pyxb.binding.datatypes.boolean(1), scope=GeometryArrayPropertyType, documentation='The AbstractGeometry element is the abstract head of the substitution group for all geometry elements of GML. This includes pre-defined and user-defined geometry elements. Any geometry element shall be a direct or indirect extension/restriction of AbstractGeometryType and shall be directly or indirectly in the substitution group of AbstractGeometry.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic0d1d.xsd', 50, 1)))

def _BuildAutomaton_21 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_21
    del _BuildAutomaton_21
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic0d1d.xsd', 71, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(GeometryArrayPropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractGeometry')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic0d1d.xsd', 72, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
GeometryArrayPropertyType._Automaton = _BuildAutomaton_21()




PointArrayPropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'Point'), PointType, scope=PointArrayPropertyType, documentation='A Point is defined by a single coordinate tuple. The direct position of a point is specified by the pos element which is of type DirectPositionType.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic0d1d.xsd', 189, 1)))

def _BuildAutomaton_22 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_22
    del _BuildAutomaton_22
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic0d1d.xsd', 213, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(PointArrayPropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'Point')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic0d1d.xsd', 214, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
PointArrayPropertyType._Automaton = _BuildAutomaton_22()




CurveArrayPropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractCurve'), AbstractCurveType, abstract=pyxb.binding.datatypes.boolean(1), scope=CurveArrayPropertyType, documentation='The AbstractCurve element is the abstract head of the substitution group for all (continuous) curve elements.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic0d1d.xsd', 226, 1)))

def _BuildAutomaton_23 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_23
    del _BuildAutomaton_23
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic0d1d.xsd', 250, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(CurveArrayPropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractCurve')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic0d1d.xsd', 251, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
CurveArrayPropertyType._Automaton = _BuildAutomaton_23()




SurfaceArrayPropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractSurface'), AbstractSurfaceType, abstract=pyxb.binding.datatypes.boolean(1), scope=SurfaceArrayPropertyType, documentation='The AbstractSurface element is the abstract head of the substitution group for all (continuous) surface elements.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic2d.xsd', 22, 1)))

def _BuildAutomaton_24 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_24
    del _BuildAutomaton_24
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic2d.xsd', 46, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(SurfaceArrayPropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractSurface')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic2d.xsd', 47, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
SurfaceArrayPropertyType._Automaton = _BuildAutomaton_24()




AbstractRingPropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractRing'), AbstractRingType, abstract=pyxb.binding.datatypes.boolean(1), scope=AbstractRingPropertyType, documentation='An abstraction of a ring to support surface boundaries of different complexity.\nThe AbstractRing element is the abstract head of the substituition group for all closed boundaries of a surface patch.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic2d.xsd', 84, 1)))

def _BuildAutomaton_25 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_25
    del _BuildAutomaton_25
    import pyxb.utils.fac as fac

    counters = set()
    states = []
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(AbstractRingPropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractRing')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic2d.xsd', 95, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
AbstractRingPropertyType._Automaton = _BuildAutomaton_25()




LinearRingPropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'LinearRing'), LinearRingType, scope=LinearRingPropertyType, documentation='A LinearRing is defined by four or more coordinate tuples, with linear interpolation between them; the first and last coordinates shall be coincident. The number of direct positions in the list shall be at least four.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic2d.xsd', 115, 1)))

def _BuildAutomaton_26 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_26
    del _BuildAutomaton_26
    import pyxb.utils.fac as fac

    counters = set()
    states = []
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(LinearRingPropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'LinearRing')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic2d.xsd', 125, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
LinearRingPropertyType._Automaton = _BuildAutomaton_26()




CurveSegmentArrayPropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractCurveSegment'), AbstractCurveSegmentType, abstract=pyxb.binding.datatypes.boolean(1), scope=CurveSegmentArrayPropertyType, documentation='A curve segment defines a homogeneous segment of a curve.\nThe attributes numDerivativesAtStart, numDerivativesAtEnd and numDerivativesInterior specify the type of continuity as specified in ISO 19107:2003, 6.4.9.3.\nThe AbstractCurveSegment element is the abstract head of the substituition group for all curve segment elements, i.e. continuous segments of the same interpolation mechanism.\nAll curve segments shall have an attribute interpolation with type gml:CurveInterpolationType specifying the curve interpolation mechanism used for this segment. This mechanism uses the control points and control parameters to determine the position of this curve segment.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 57, 1)))

def _BuildAutomaton_27 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_27
    del _BuildAutomaton_27
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 69, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(CurveSegmentArrayPropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractCurveSegment')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 70, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
CurveSegmentArrayPropertyType._Automaton = _BuildAutomaton_27()




KnotType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'value'), pyxb.binding.datatypes.double, scope=KnotType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 353, 3)))

KnotType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'multiplicity'), pyxb.binding.datatypes.nonNegativeInteger, scope=KnotType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 354, 3)))

KnotType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'weight'), pyxb.binding.datatypes.double, scope=KnotType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 355, 3)))

def _BuildAutomaton_28 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_28
    del _BuildAutomaton_28
    import pyxb.utils.fac as fac

    counters = set()
    states = []
    final_update = None
    symbol = pyxb.binding.content.ElementUse(KnotType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'value')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 353, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(KnotType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'multiplicity')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 354, 3))
    st_1 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(KnotType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'weight')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 355, 3))
    st_2 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    transitions = []
    transitions.append(fac.Transition(st_1, [
         ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_2, [
         ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    st_2._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
KnotType._Automaton = _BuildAutomaton_28()




KnotPropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'Knot'), KnotType, scope=KnotPropertyType, documentation='A knot is a breakpoint on a piecewise spline curve.\nvalue is the value of the parameter at the knot of the spline (see ISO 19107:2003, 6.4.24.2).\nmultiplicity is the multiplicity of this knot used in the definition of the spline (with the same weight).\nweight is the value of the averaging weight used for this knot of the spline.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 363, 3)))

def _BuildAutomaton_29 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_29
    del _BuildAutomaton_29
    import pyxb.utils.fac as fac

    counters = set()
    states = []
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(KnotPropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'Knot')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 363, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
KnotPropertyType._Automaton = _BuildAutomaton_29()




AffinePlacementType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'location'), DirectPositionType, scope=AffinePlacementType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 435, 3)))

AffinePlacementType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'refDirection'), VectorType, scope=AffinePlacementType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 436, 3)))

AffinePlacementType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'inDimension'), pyxb.binding.datatypes.positiveInteger, scope=AffinePlacementType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 437, 3)))

AffinePlacementType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'outDimension'), pyxb.binding.datatypes.positiveInteger, scope=AffinePlacementType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 438, 3)))

def _BuildAutomaton_30 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_30
    del _BuildAutomaton_30
    import pyxb.utils.fac as fac

    counters = set()
    states = []
    final_update = None
    symbol = pyxb.binding.content.ElementUse(AffinePlacementType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'location')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 435, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(AffinePlacementType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'refDirection')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 436, 3))
    st_1 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(AffinePlacementType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'inDimension')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 437, 3))
    st_2 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(AffinePlacementType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'outDimension')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 438, 3))
    st_3 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_3)
    transitions = []
    transitions.append(fac.Transition(st_1, [
         ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_1, [
         ]))
    transitions.append(fac.Transition(st_2, [
         ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_3, [
         ]))
    st_2._set_transitionSet(transitions)
    transitions = []
    st_3._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
AffinePlacementType._Automaton = _BuildAutomaton_30()




CTD_ANON_2._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'AffinePlacement'), AffinePlacementType, scope=CTD_ANON_2, documentation='location, refDirection, inDimension and outDimension have the same meaning as specified in ISO 19107:2003, 6.4.21.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 441, 1)))

def _BuildAutomaton_31 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_31
    del _BuildAutomaton_31
    import pyxb.utils.fac as fac

    counters = set()
    states = []
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(CTD_ANON_2._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'AffinePlacement')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 453, 8))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
CTD_ANON_2._Automaton = _BuildAutomaton_31()




SurfacePatchArrayPropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractSurfacePatch'), AbstractSurfacePatchType, abstract=pyxb.binding.datatypes.boolean(1), scope=SurfacePatchArrayPropertyType, documentation='A surface patch defines a homogenuous portion of a surface. \nThe AbstractSurfacePatch element is the abstract head of the substituition group for all surface patch elements describing a continuous portion of a surface.\nAll surface patches shall have an attribute interpolation (declared in the types derived from gml:AbstractSurfacePatchType) specifying the interpolation mechanism used for the patch using gml:SurfaceInterpolationType.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 534, 1)))

def _BuildAutomaton_32 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_32
    del _BuildAutomaton_32
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 545, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(SurfacePatchArrayPropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractSurfacePatch')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 546, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
SurfacePatchArrayPropertyType._Automaton = _BuildAutomaton_32()




RingPropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'Ring'), RingType, scope=RingPropertyType, documentation='A ring is used to represent a single connected component of a surface boundary as specified in ISO 19107:2003, 6.3.6.\nEvery gml:curveMember references or contains one curve, i.e. any element which is substitutable for gml:AbstractCurve. In the context of a ring, the curves describe the boundary of the surface. The sequence of curves shall be contiguous and connected in a cycle.\nIf provided, the aggregationType attribute shall have the value "sequence".', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 632, 1)))

def _BuildAutomaton_33 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_33
    del _BuildAutomaton_33
    import pyxb.utils.fac as fac

    counters = set()
    states = []
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(RingPropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'Ring')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 645, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
RingPropertyType._Automaton = _BuildAutomaton_33()




CTD_ANON_3._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'Row'), CTD_ANON_4, scope=CTD_ANON_3, location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 656, 6)))

def _BuildAutomaton_34 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_34
    del _BuildAutomaton_34
    import pyxb.utils.fac as fac

    counters = set()
    states = []
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(CTD_ANON_3._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'Row')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 656, 6))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
         ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
CTD_ANON_3._Automaton = _BuildAutomaton_34()




CTD_ANON_4._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'pos'), DirectPositionType, scope=CTD_ANON_4, location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic0d1d.xsd', 87, 1)))

CTD_ANON_4._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'posList'), DirectPositionListType, scope=CTD_ANON_4, location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic0d1d.xsd', 102, 1)))

CTD_ANON_4._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'pointProperty'), PointPropertyType, scope=CTD_ANON_4, documentation='This property element either references a point via the XLink-attributes or contains the point element. pointProperty is the predefined property which may be used by GML Application Schemas whenever a GML feature has a property with a value that is substitutable for Point.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic0d1d.xsd', 204, 1)))

def _BuildAutomaton_35 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_35
    del _BuildAutomaton_35
    import pyxb.utils.fac as fac

    counters = set()
    states = []
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(CTD_ANON_4._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'posList')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic0d1d.xsd', 120, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(CTD_ANON_4._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'pos')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic0d1d.xsd', 110, 3))
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(CTD_ANON_4._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'pointProperty')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic0d1d.xsd', 111, 3))
    st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    transitions = []
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_1, [
         ]))
    transitions.append(fac.Transition(st_2, [
         ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_1, [
         ]))
    transitions.append(fac.Transition(st_2, [
         ]))
    st_2._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
CTD_ANON_4._Automaton = _BuildAutomaton_35()




CTD_ANON_5._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'pos'), DirectPositionType, scope=CTD_ANON_5, location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic0d1d.xsd', 87, 1)))

CTD_ANON_5._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'posList'), DirectPositionListType, scope=CTD_ANON_5, location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic0d1d.xsd', 102, 1)))

CTD_ANON_5._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'pointProperty'), PointPropertyType, scope=CTD_ANON_5, documentation='This property element either references a point via the XLink-attributes or contains the point element. pointProperty is the predefined property which may be used by GML Application Schemas whenever a GML feature has a property with a value that is substitutable for Point.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic0d1d.xsd', 204, 1)))

def _BuildAutomaton_36 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_36
    del _BuildAutomaton_36
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=3, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 746, 8))
    counters.add(cc_0)
    states = []
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(CTD_ANON_5._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'posList')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 745, 8))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(CTD_ANON_5._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'pos')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic0d1d.xsd', 110, 3))
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(CTD_ANON_5._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'pointProperty')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic0d1d.xsd', 111, 3))
    st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    transitions = []
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_2._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
CTD_ANON_5._Automaton = _BuildAutomaton_36()




LineStringSegmentArrayPropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'LineStringSegment'), LineStringSegmentType, scope=LineStringSegmentArrayPropertyType, documentation='A LineStringSegment is a curve segment that is defined by two or more control points including the start and end point, with linear interpolation between them.\nThe content model follows the general pattern for the encoding of curve segments.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 114, 1)))

def _BuildAutomaton_37 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_37
    del _BuildAutomaton_37
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 763, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(LineStringSegmentArrayPropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'LineStringSegment')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 764, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
LineStringSegmentArrayPropertyType._Automaton = _BuildAutomaton_37()




SolidArrayPropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractSolid'), AbstractSolidType, abstract=pyxb.binding.datatypes.boolean(1), scope=SolidArrayPropertyType, documentation='The AbstractSolid element is the abstract head of the substituition group for all (continuous) solid elements.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 775, 1)))

def _BuildAutomaton_38 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_38
    del _BuildAutomaton_38
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 799, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(SolidArrayPropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractSolid')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 800, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
SolidArrayPropertyType._Automaton = _BuildAutomaton_38()




ShellPropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'Shell'), ShellType, scope=ShellPropertyType, documentation='A shell is used to represent a single connected component of a solid boundary as specified in ISO 19107:2003, 6.3.8.\nEvery gml:surfaceMember references or contains one surface, i.e. any element which is substitutable for gml:AbstractSurface. In the context of a shell, the surfaces describe the boundary of the solid. \nIf provided, the aggregationType attribute shall have the value "set".\n', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 829, 1)))

def _BuildAutomaton_39 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_39
    del _BuildAutomaton_39
    import pyxb.utils.fac as fac

    counters = set()
    states = []
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(ShellPropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'Shell')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 847, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
ShellPropertyType._Automaton = _BuildAutomaton_39()




AbstractGMLType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'metaDataProperty'), MetaDataPropertyType, scope=AbstractGMLType, documentation='', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 672, 1)))

AbstractGMLType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'description'), StringOrRefType, scope=AbstractGMLType, documentation='The value of this property is a text description of the object. gml:description uses gml:StringOrRefType as its content model, so it may contain a simple text string content, or carry a reference to an external description. The use of gml:description to reference an external description has been deprecated and replaced by the gml:descriptionReference property.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 117, 1)))

AbstractGMLType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'descriptionReference'), ReferenceType, scope=AbstractGMLType, documentation='The value of this property is a remote text description of the object. The xlink:href attribute of the gml:descriptionReference property references the external description.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 122, 1)))

AbstractGMLType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'name'), CodeType, scope=AbstractGMLType, documentation='The gml:name property provides a label or identifier for the object, commonly a descriptive name. An object may have several names, typically assigned by different authorities. gml:name uses the gml:CodeType content model.  The authority for a name is indicated by the value of its (optional) codeSpace attribute.  The name may or may not be unique, as determined by the rules of the organization responsible for the codeSpace.  In common usage there will be one name per authority, so a processing application may select the name from its preferred codeSpace.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 127, 1)))

AbstractGMLType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'identifier'), CodeWithAuthorityType, scope=AbstractGMLType, documentation='Often, a special identifier is assigned to an object by the maintaining authority with the intention that it is used in references to the object For such cases, the codeSpace shall be provided. That identifier is usually unique either globally or within an application domain. gml:identifier is a pre-defined property for such identifiers.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 132, 1)))

def _BuildAutomaton_40 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_40
    del _BuildAutomaton_40
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 39, 3))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 40, 3))
    counters.add(cc_1)
    cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 41, 3))
    counters.add(cc_2)
    cc_3 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 42, 3))
    counters.add(cc_3)
    cc_4 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 43, 3))
    counters.add(cc_4)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(AbstractGMLType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'metaDataProperty')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 39, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_1, False))
    symbol = pyxb.binding.content.ElementUse(AbstractGMLType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'description')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 40, 3))
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_2, False))
    symbol = pyxb.binding.content.ElementUse(AbstractGMLType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'descriptionReference')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 41, 3))
    st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_3, False))
    symbol = pyxb.binding.content.ElementUse(AbstractGMLType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'identifier')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 42, 3))
    st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_3)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_4, False))
    symbol = pyxb.binding.content.ElementUse(AbstractGMLType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'name')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 43, 3))
    st_4 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_4)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_1, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_1, False) ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_2, True) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_2, False) ]))
    st_2._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_3, True) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_3, False) ]))
    st_3._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_4, True) ]))
    st_4._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
AbstractGMLType._Automaton = _BuildAutomaton_40()




def _BuildAutomaton_41 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_41
    del _BuildAutomaton_41
    import pyxb.utils.fac as fac

    counters = set()
    states = []
    final_update = set()
    symbol = pyxb.binding.content.WildcardUse(pyxb.binding.content.Wildcard(process_contents=pyxb.binding.content.Wildcard.PC_strict, namespace_constraint=pyxb.binding.content.Wildcard.NC_any), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 108, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
InlinePropertyType._Automaton = _BuildAutomaton_41()




GridLimitsType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'GridEnvelope'), GridEnvelopeType, scope=GridLimitsType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/grids.xsd', 39, 3)))

def _BuildAutomaton_42 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_42
    del _BuildAutomaton_42
    import pyxb.utils.fac as fac

    counters = set()
    states = []
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(GridLimitsType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'GridEnvelope')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/grids.xsd', 39, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
GridLimitsType._Automaton = _BuildAutomaton_42()




GridEnvelopeType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'low'), integerList, scope=GridEnvelopeType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/grids.xsd', 44, 3)))

GridEnvelopeType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'high'), integerList, scope=GridEnvelopeType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/grids.xsd', 45, 3)))

def _BuildAutomaton_43 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_43
    del _BuildAutomaton_43
    import pyxb.utils.fac as fac

    counters = set()
    states = []
    final_update = None
    symbol = pyxb.binding.content.ElementUse(GridEnvelopeType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'low')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/grids.xsd', 44, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(GridEnvelopeType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'high')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/grids.xsd', 45, 3))
    st_1 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    transitions = []
    transitions.append(fac.Transition(st_1, [
         ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    st_1._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
GridEnvelopeType._Automaton = _BuildAutomaton_43()




TopoPointPropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'TopoPoint'), TopoPointType, scope=TopoPointPropertyType, documentation='The intended use of gml:TopoPoint is to appear within a point feature to express the structural and possibly geometric relationships of this feature to other features via shared node definitions.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/topology.xsd', 224, 2)))

def _BuildAutomaton_44 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_44
    del _BuildAutomaton_44
    import pyxb.utils.fac as fac

    counters = set()
    states = []
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(TopoPointPropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'TopoPoint')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/topology.xsd', 231, 6))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
TopoPointPropertyType._Automaton = _BuildAutomaton_44()




TopoCurvePropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'TopoCurve'), TopoCurveType, scope=TopoCurvePropertyType, documentation='gml:TopoCurve represents a homogeneous topological expression, a sequence of directed edges, which if realised are isomorphic to a geometric curve primitive. The intended use of gml:TopoCurve is to appear within a line feature to express the structural and geometric relationships of this feature to other features via the shared edge definitions.\nIf provided, the aggregationType attribute shall have the value "sequence".', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/topology.xsd', 250, 2)))

def _BuildAutomaton_45 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_45
    del _BuildAutomaton_45
    import pyxb.utils.fac as fac

    counters = set()
    states = []
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(TopoCurvePropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'TopoCurve')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/topology.xsd', 258, 6))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
TopoCurvePropertyType._Automaton = _BuildAutomaton_45()




TopoSurfacePropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'TopoSurface'), TopoSurfaceType, scope=TopoSurfacePropertyType, documentation='gml:TopoSurface represents a homogeneous topological expression, a set of directed faces, which if realised are isomorphic to a geometric surface primitive. The intended use of gml:TopoSurface is to appear within a surface feature to express the structural and possibly geometric relationships of this surface feature to other features via the shared face definitions.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/topology.xsd', 277, 2)))

def _BuildAutomaton_46 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_46
    del _BuildAutomaton_46
    import pyxb.utils.fac as fac

    counters = set()
    states = []
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(TopoSurfacePropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'TopoSurface')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/topology.xsd', 284, 6))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
TopoSurfacePropertyType._Automaton = _BuildAutomaton_46()




TopoVolumePropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'TopoVolume'), TopoVolumeType, scope=TopoVolumePropertyType, documentation='gml:TopoVolume represents a homogeneous topological expression, a set of directed topologic solids, which if realised are isomorphic to a geometric solid primitive. The intended use of gml:TopoVolume is to appear within a solid feature to express the structural and geometric relationships of this solid feature to other features via the shared solid definitions.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/topology.xsd', 303, 2)))

def _BuildAutomaton_47 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_47
    del _BuildAutomaton_47
    import pyxb.utils.fac as fac

    counters = set()
    states = []
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(TopoVolumePropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'TopoVolume')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/topology.xsd', 310, 6))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
TopoVolumePropertyType._Automaton = _BuildAutomaton_47()




TopoPrimitiveArrayAssociationType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractTopoPrimitive'), AbstractTopoPrimitiveType, abstract=pyxb.binding.datatypes.boolean(1), scope=TopoPrimitiveArrayAssociationType, documentation='gml:AbstractTopoPrimitive acts as the base type for all topological primitives. Topology primitives are the atomic (smallest possible) units of a topology complex. \nEach topology primitive may contain references to other topology primitives of codimension 2 or more (gml:isolated). Conversely, nodes may have faces as containers and nodes and edges may have solids as containers (gml:container).', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/topology.xsd', 31, 2)))

def _BuildAutomaton_48 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_48
    del _BuildAutomaton_48
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/topology.xsd', 375, 4))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(TopoPrimitiveArrayAssociationType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractTopoPrimitive')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/topology.xsd', 376, 6))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
TopoPrimitiveArrayAssociationType._Automaton = _BuildAutomaton_48()




FormulaType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'a'), pyxb.binding.datatypes.double, scope=FormulaType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/units.xsd', 156, 3)))

FormulaType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'b'), pyxb.binding.datatypes.double, scope=FormulaType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/units.xsd', 157, 3)))

FormulaType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'c'), pyxb.binding.datatypes.double, scope=FormulaType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/units.xsd', 158, 3)))

FormulaType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'd'), pyxb.binding.datatypes.double, scope=FormulaType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/units.xsd', 159, 3)))

def _BuildAutomaton_49 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_49
    del _BuildAutomaton_49
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/units.xsd', 156, 3))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/units.xsd', 159, 3))
    counters.add(cc_1)
    states = []
    final_update = None
    symbol = pyxb.binding.content.ElementUse(FormulaType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'a')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/units.xsd', 156, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(FormulaType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'b')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/units.xsd', 157, 3))
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(FormulaType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'c')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/units.xsd', 158, 3))
    st_2 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_1, False))
    symbol = pyxb.binding.content.ElementUse(FormulaType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'd')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/units.xsd', 159, 3))
    st_3 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_3)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_2, [
         ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_3, [
         ]))
    st_2._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_1, True) ]))
    st_3._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
FormulaType._Automaton = _BuildAutomaton_49()




ValueArrayPropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'Null'), NilReasonType, scope=ValueArrayPropertyType, documentation='', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 13, 1)))

ValueArrayPropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractGeometry'), AbstractGeometryType, abstract=pyxb.binding.datatypes.boolean(1), scope=ValueArrayPropertyType, documentation='The AbstractGeometry element is the abstract head of the substitution group for all geometry elements of GML. This includes pre-defined and user-defined geometry elements. Any geometry element shall be a direct or indirect extension/restriction of AbstractGeometryType and shall be directly or indirectly in the substitution group of AbstractGeometry.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic0d1d.xsd', 50, 1)))

ValueArrayPropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractTimeObject'), AbstractTimeObjectType, abstract=pyxb.binding.datatypes.boolean(1), scope=ValueArrayPropertyType, documentation='gml:AbstractTimeObject acts as the head of a substitution group for all temporal primitives and complexes.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporal.xsd', 18, 1)))

ValueArrayPropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractValue'), pyxb.binding.datatypes.anyType, abstract=pyxb.binding.datatypes.boolean(1), scope=ValueArrayPropertyType, documentation='gml:AbstractValue is an abstract element which acts as the head of a substitution group which contains gml:AbstractScalarValue, gml:AbstractScalarValueList, gml:CompositeValue and gml:ValueExtent, and (transitively) the elements in their substitution groups.\nThese elements may be used in an application schema as variables, so that in an XML instance document any member of its substitution group may occur.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/valueObjects.xsd', 70, 1)))

def _BuildAutomaton_50 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_50
    del _BuildAutomaton_50
    import pyxb.utils.fac as fac

    counters = set()
    states = []
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(ValueArrayPropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractValue')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/valueObjects.xsd', 91, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(ValueArrayPropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractGeometry')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/valueObjects.xsd', 92, 3))
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(ValueArrayPropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractTimeObject')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/valueObjects.xsd', 93, 3))
    st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(ValueArrayPropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'Null')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/valueObjects.xsd', 94, 3))
    st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_3)
    transitions = []
    transitions.append(fac.Transition(st_0, [
         ]))
    transitions.append(fac.Transition(st_1, [
         ]))
    transitions.append(fac.Transition(st_2, [
         ]))
    transitions.append(fac.Transition(st_3, [
         ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_0, [
         ]))
    transitions.append(fac.Transition(st_1, [
         ]))
    transitions.append(fac.Transition(st_2, [
         ]))
    transitions.append(fac.Transition(st_3, [
         ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_0, [
         ]))
    transitions.append(fac.Transition(st_1, [
         ]))
    transitions.append(fac.Transition(st_2, [
         ]))
    transitions.append(fac.Transition(st_3, [
         ]))
    st_2._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_0, [
         ]))
    transitions.append(fac.Transition(st_1, [
         ]))
    transitions.append(fac.Transition(st_2, [
         ]))
    transitions.append(fac.Transition(st_3, [
         ]))
    st_3._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
ValueArrayPropertyType._Automaton = _BuildAutomaton_50()




TypeName_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gco, 'aName'), CharacterString_PropertyType, scope=TypeName_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 24, 5)))

def _BuildAutomaton_51 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_51
    del _BuildAutomaton_51
    import pyxb.utils.fac as fac

    counters = set()
    states = []
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(TypeName_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gco, 'aName')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 24, 5))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
TypeName_Type._Automaton = _BuildAutomaton_51()




MemberName_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gco, 'aName'), CharacterString_PropertyType, scope=MemberName_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 47, 5)))

MemberName_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gco, 'attributeType'), TypeName_PropertyType, scope=MemberName_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 48, 5)))

def _BuildAutomaton_52 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_52
    del _BuildAutomaton_52
    import pyxb.utils.fac as fac

    counters = set()
    states = []
    final_update = None
    symbol = pyxb.binding.content.ElementUse(MemberName_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gco, 'aName')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 47, 5))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(MemberName_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gco, 'attributeType')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 48, 5))
    st_1 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    transitions = []
    transitions.append(fac.Transition(st_1, [
         ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    st_1._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
MemberName_Type._Automaton = _BuildAutomaton_52()




Multiplicity_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gco, 'range'), MultiplicityRange_PropertyType, scope=Multiplicity_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 71, 5)))

def _BuildAutomaton_53 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_53
    del _BuildAutomaton_53
    import pyxb.utils.fac as fac

    counters = set()
    states = []
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(Multiplicity_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gco, 'range')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 71, 5))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
         ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
Multiplicity_Type._Automaton = _BuildAutomaton_53()




MultiplicityRange_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gco, 'lower'), Integer_PropertyType, scope=MultiplicityRange_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 94, 5)))

MultiplicityRange_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gco, 'upper'), UnlimitedInteger_PropertyType, scope=MultiplicityRange_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 95, 5)))

def _BuildAutomaton_54 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_54
    del _BuildAutomaton_54
    import pyxb.utils.fac as fac

    counters = set()
    states = []
    final_update = None
    symbol = pyxb.binding.content.ElementUse(MultiplicityRange_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gco, 'lower')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 94, 5))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(MultiplicityRange_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gco, 'upper')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 95, 5))
    st_1 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    transitions = []
    transitions.append(fac.Transition(st_1, [
         ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    st_1._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
MultiplicityRange_Type._Automaton = _BuildAutomaton_54()




MD_ApplicationSchemaInformation_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'name'), CI_Citation_PropertyType, scope=MD_ApplicationSchemaInformation_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/applicationSchema.xsd', 21, 5)))

MD_ApplicationSchemaInformation_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'schemaLanguage'), CharacterString_PropertyType, scope=MD_ApplicationSchemaInformation_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/applicationSchema.xsd', 22, 5)))

MD_ApplicationSchemaInformation_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'constraintLanguage'), CharacterString_PropertyType, scope=MD_ApplicationSchemaInformation_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/applicationSchema.xsd', 23, 5)))

MD_ApplicationSchemaInformation_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'schemaAscii'), CharacterString_PropertyType, scope=MD_ApplicationSchemaInformation_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/applicationSchema.xsd', 24, 5)))

MD_ApplicationSchemaInformation_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'graphicsFile'), Binary_PropertyType, scope=MD_ApplicationSchemaInformation_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/applicationSchema.xsd', 25, 5)))

MD_ApplicationSchemaInformation_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'softwareDevelopmentFile'), Binary_PropertyType, scope=MD_ApplicationSchemaInformation_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/applicationSchema.xsd', 26, 5)))

MD_ApplicationSchemaInformation_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'softwareDevelopmentFileFormat'), CharacterString_PropertyType, scope=MD_ApplicationSchemaInformation_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/applicationSchema.xsd', 27, 5)))

def _BuildAutomaton_55 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_55
    del _BuildAutomaton_55
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/applicationSchema.xsd', 24, 5))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/applicationSchema.xsd', 25, 5))
    counters.add(cc_1)
    cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/applicationSchema.xsd', 26, 5))
    counters.add(cc_2)
    cc_3 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/applicationSchema.xsd', 27, 5))
    counters.add(cc_3)
    states = []
    final_update = None
    symbol = pyxb.binding.content.ElementUse(MD_ApplicationSchemaInformation_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'name')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/applicationSchema.xsd', 21, 5))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(MD_ApplicationSchemaInformation_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'schemaLanguage')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/applicationSchema.xsd', 22, 5))
    st_1 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(MD_ApplicationSchemaInformation_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'constraintLanguage')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/applicationSchema.xsd', 23, 5))
    st_2 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(MD_ApplicationSchemaInformation_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'schemaAscii')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/applicationSchema.xsd', 24, 5))
    st_3 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_3)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_1, False))
    symbol = pyxb.binding.content.ElementUse(MD_ApplicationSchemaInformation_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'graphicsFile')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/applicationSchema.xsd', 25, 5))
    st_4 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_4)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_2, False))
    symbol = pyxb.binding.content.ElementUse(MD_ApplicationSchemaInformation_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'softwareDevelopmentFile')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/applicationSchema.xsd', 26, 5))
    st_5 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_5)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_3, False))
    symbol = pyxb.binding.content.ElementUse(MD_ApplicationSchemaInformation_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'softwareDevelopmentFileFormat')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/applicationSchema.xsd', 27, 5))
    st_6 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_6)
    transitions = []
    transitions.append(fac.Transition(st_1, [
         ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_2, [
         ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_3, [
         ]))
    transitions.append(fac.Transition(st_4, [
         ]))
    transitions.append(fac.Transition(st_5, [
         ]))
    transitions.append(fac.Transition(st_6, [
         ]))
    st_2._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_3._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_1, True) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_1, False) ]))
    st_4._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_2, True) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_2, False) ]))
    st_5._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_3, True) ]))
    st_6._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
MD_ApplicationSchemaInformation_Type._Automaton = _BuildAutomaton_55()




CI_ResponsibleParty_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'individualName'), CharacterString_PropertyType, scope=CI_ResponsibleParty_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 21, 5)))

CI_ResponsibleParty_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'organisationName'), CharacterString_PropertyType, scope=CI_ResponsibleParty_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 22, 5)))

CI_ResponsibleParty_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'positionName'), CharacterString_PropertyType, scope=CI_ResponsibleParty_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 23, 5)))

CI_ResponsibleParty_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'contactInfo'), CI_Contact_PropertyType, scope=CI_ResponsibleParty_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 24, 5)))

CI_ResponsibleParty_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'role'), CI_RoleCode_PropertyType, scope=CI_ResponsibleParty_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 25, 5)))

def _BuildAutomaton_56 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_56
    del _BuildAutomaton_56
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 21, 5))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 22, 5))
    counters.add(cc_1)
    cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 23, 5))
    counters.add(cc_2)
    cc_3 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 24, 5))
    counters.add(cc_3)
    states = []
    final_update = None
    symbol = pyxb.binding.content.ElementUse(CI_ResponsibleParty_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'individualName')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 21, 5))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(CI_ResponsibleParty_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'organisationName')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 22, 5))
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(CI_ResponsibleParty_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'positionName')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 23, 5))
    st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(CI_ResponsibleParty_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'contactInfo')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 24, 5))
    st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_3)
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(CI_ResponsibleParty_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'role')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 25, 5))
    st_4 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_4)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_1, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_1, False) ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_2, True) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_2, False) ]))
    st_2._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_3, True) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_3, False) ]))
    st_3._set_transitionSet(transitions)
    transitions = []
    st_4._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
CI_ResponsibleParty_Type._Automaton = _BuildAutomaton_56()




CI_Citation_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'title'), CharacterString_PropertyType, scope=CI_Citation_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 48, 5)))

CI_Citation_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'alternateTitle'), CharacterString_PropertyType, scope=CI_Citation_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 49, 5)))

CI_Citation_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'date'), CI_Date_PropertyType, scope=CI_Citation_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 50, 5)))

CI_Citation_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'edition'), CharacterString_PropertyType, scope=CI_Citation_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 51, 5)))

CI_Citation_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'editionDate'), Date_PropertyType, scope=CI_Citation_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 52, 5)))

CI_Citation_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'identifier'), MD_Identifier_PropertyType, scope=CI_Citation_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 53, 5)))

CI_Citation_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'citedResponsibleParty'), CI_ResponsibleParty_PropertyType, scope=CI_Citation_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 54, 5)))

CI_Citation_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'presentationForm'), CI_PresentationFormCode_PropertyType, scope=CI_Citation_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 55, 5)))

CI_Citation_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'series'), CI_Series_PropertyType, scope=CI_Citation_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 56, 5)))

CI_Citation_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'otherCitationDetails'), CharacterString_PropertyType, scope=CI_Citation_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 57, 5)))

CI_Citation_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'collectiveTitle'), CharacterString_PropertyType, scope=CI_Citation_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 58, 5)))

CI_Citation_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'ISBN'), CharacterString_PropertyType, scope=CI_Citation_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 59, 5)))

CI_Citation_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'ISSN'), CharacterString_PropertyType, scope=CI_Citation_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 60, 5)))

def _BuildAutomaton_57 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_57
    del _BuildAutomaton_57
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 49, 5))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 51, 5))
    counters.add(cc_1)
    cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 52, 5))
    counters.add(cc_2)
    cc_3 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 53, 5))
    counters.add(cc_3)
    cc_4 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 54, 5))
    counters.add(cc_4)
    cc_5 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 55, 5))
    counters.add(cc_5)
    cc_6 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 56, 5))
    counters.add(cc_6)
    cc_7 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 57, 5))
    counters.add(cc_7)
    cc_8 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 58, 5))
    counters.add(cc_8)
    cc_9 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 59, 5))
    counters.add(cc_9)
    cc_10 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 60, 5))
    counters.add(cc_10)
    states = []
    final_update = None
    symbol = pyxb.binding.content.ElementUse(CI_Citation_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'title')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 48, 5))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(CI_Citation_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'alternateTitle')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 49, 5))
    st_1 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(CI_Citation_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'date')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 50, 5))
    st_2 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_1, False))
    symbol = pyxb.binding.content.ElementUse(CI_Citation_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'edition')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 51, 5))
    st_3 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_3)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_2, False))
    symbol = pyxb.binding.content.ElementUse(CI_Citation_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'editionDate')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 52, 5))
    st_4 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_4)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_3, False))
    symbol = pyxb.binding.content.ElementUse(CI_Citation_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'identifier')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 53, 5))
    st_5 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_5)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_4, False))
    symbol = pyxb.binding.content.ElementUse(CI_Citation_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'citedResponsibleParty')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 54, 5))
    st_6 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_6)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_5, False))
    symbol = pyxb.binding.content.ElementUse(CI_Citation_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'presentationForm')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 55, 5))
    st_7 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_7)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_6, False))
    symbol = pyxb.binding.content.ElementUse(CI_Citation_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'series')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 56, 5))
    st_8 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_8)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_7, False))
    symbol = pyxb.binding.content.ElementUse(CI_Citation_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'otherCitationDetails')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 57, 5))
    st_9 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_9)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_8, False))
    symbol = pyxb.binding.content.ElementUse(CI_Citation_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'collectiveTitle')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 58, 5))
    st_10 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_10)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_9, False))
    symbol = pyxb.binding.content.ElementUse(CI_Citation_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'ISBN')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 59, 5))
    st_11 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_11)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_10, False))
    symbol = pyxb.binding.content.ElementUse(CI_Citation_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'ISSN')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 60, 5))
    st_12 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_12)
    transitions = []
    transitions.append(fac.Transition(st_1, [
         ]))
    transitions.append(fac.Transition(st_2, [
         ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_2, [
         ]))
    transitions.append(fac.Transition(st_3, [
         ]))
    transitions.append(fac.Transition(st_4, [
         ]))
    transitions.append(fac.Transition(st_5, [
         ]))
    transitions.append(fac.Transition(st_6, [
         ]))
    transitions.append(fac.Transition(st_7, [
         ]))
    transitions.append(fac.Transition(st_8, [
         ]))
    transitions.append(fac.Transition(st_9, [
         ]))
    transitions.append(fac.Transition(st_10, [
         ]))
    transitions.append(fac.Transition(st_11, [
         ]))
    transitions.append(fac.Transition(st_12, [
         ]))
    st_2._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_1, True) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_8, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_9, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_10, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_11, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_12, [
        fac.UpdateInstruction(cc_1, False) ]))
    st_3._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_2, True) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_8, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_9, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_10, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_11, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_12, [
        fac.UpdateInstruction(cc_2, False) ]))
    st_4._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_3, True) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_8, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_9, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_10, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_11, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_12, [
        fac.UpdateInstruction(cc_3, False) ]))
    st_5._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_4, True) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_4, False) ]))
    transitions.append(fac.Transition(st_8, [
        fac.UpdateInstruction(cc_4, False) ]))
    transitions.append(fac.Transition(st_9, [
        fac.UpdateInstruction(cc_4, False) ]))
    transitions.append(fac.Transition(st_10, [
        fac.UpdateInstruction(cc_4, False) ]))
    transitions.append(fac.Transition(st_11, [
        fac.UpdateInstruction(cc_4, False) ]))
    transitions.append(fac.Transition(st_12, [
        fac.UpdateInstruction(cc_4, False) ]))
    st_6._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_5, True) ]))
    transitions.append(fac.Transition(st_8, [
        fac.UpdateInstruction(cc_5, False) ]))
    transitions.append(fac.Transition(st_9, [
        fac.UpdateInstruction(cc_5, False) ]))
    transitions.append(fac.Transition(st_10, [
        fac.UpdateInstruction(cc_5, False) ]))
    transitions.append(fac.Transition(st_11, [
        fac.UpdateInstruction(cc_5, False) ]))
    transitions.append(fac.Transition(st_12, [
        fac.UpdateInstruction(cc_5, False) ]))
    st_7._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_8, [
        fac.UpdateInstruction(cc_6, True) ]))
    transitions.append(fac.Transition(st_9, [
        fac.UpdateInstruction(cc_6, False) ]))
    transitions.append(fac.Transition(st_10, [
        fac.UpdateInstruction(cc_6, False) ]))
    transitions.append(fac.Transition(st_11, [
        fac.UpdateInstruction(cc_6, False) ]))
    transitions.append(fac.Transition(st_12, [
        fac.UpdateInstruction(cc_6, False) ]))
    st_8._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_9, [
        fac.UpdateInstruction(cc_7, True) ]))
    transitions.append(fac.Transition(st_10, [
        fac.UpdateInstruction(cc_7, False) ]))
    transitions.append(fac.Transition(st_11, [
        fac.UpdateInstruction(cc_7, False) ]))
    transitions.append(fac.Transition(st_12, [
        fac.UpdateInstruction(cc_7, False) ]))
    st_9._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_10, [
        fac.UpdateInstruction(cc_8, True) ]))
    transitions.append(fac.Transition(st_11, [
        fac.UpdateInstruction(cc_8, False) ]))
    transitions.append(fac.Transition(st_12, [
        fac.UpdateInstruction(cc_8, False) ]))
    st_10._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_11, [
        fac.UpdateInstruction(cc_9, True) ]))
    transitions.append(fac.Transition(st_12, [
        fac.UpdateInstruction(cc_9, False) ]))
    st_11._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_12, [
        fac.UpdateInstruction(cc_10, True) ]))
    st_12._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
CI_Citation_Type._Automaton = _BuildAutomaton_57()




CI_Address_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'deliveryPoint'), CharacterString_PropertyType, scope=CI_Address_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 83, 5)))

CI_Address_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'city'), CharacterString_PropertyType, scope=CI_Address_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 84, 5)))

CI_Address_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'administrativeArea'), CharacterString_PropertyType, scope=CI_Address_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 85, 5)))

CI_Address_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'postalCode'), CharacterString_PropertyType, scope=CI_Address_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 86, 5)))

CI_Address_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'country'), CharacterString_PropertyType, scope=CI_Address_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 87, 5)))

CI_Address_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'electronicMailAddress'), CharacterString_PropertyType, scope=CI_Address_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 88, 5)))

def _BuildAutomaton_58 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_58
    del _BuildAutomaton_58
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 83, 5))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 84, 5))
    counters.add(cc_1)
    cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 85, 5))
    counters.add(cc_2)
    cc_3 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 86, 5))
    counters.add(cc_3)
    cc_4 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 87, 5))
    counters.add(cc_4)
    cc_5 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 88, 5))
    counters.add(cc_5)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(CI_Address_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'deliveryPoint')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 83, 5))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_1, False))
    symbol = pyxb.binding.content.ElementUse(CI_Address_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'city')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 84, 5))
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_2, False))
    symbol = pyxb.binding.content.ElementUse(CI_Address_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'administrativeArea')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 85, 5))
    st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_3, False))
    symbol = pyxb.binding.content.ElementUse(CI_Address_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'postalCode')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 86, 5))
    st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_3)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_4, False))
    symbol = pyxb.binding.content.ElementUse(CI_Address_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'country')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 87, 5))
    st_4 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_4)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_5, False))
    symbol = pyxb.binding.content.ElementUse(CI_Address_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'electronicMailAddress')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 88, 5))
    st_5 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_5)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_1, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_1, False) ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_2, True) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_2, False) ]))
    st_2._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_3, True) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_3, False) ]))
    st_3._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_4, True) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_4, False) ]))
    st_4._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_5, True) ]))
    st_5._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
CI_Address_Type._Automaton = _BuildAutomaton_58()




CI_OnlineResource_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'linkage'), URL_PropertyType, scope=CI_OnlineResource_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 111, 5)))

CI_OnlineResource_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'protocol'), CharacterString_PropertyType, scope=CI_OnlineResource_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 112, 5)))

CI_OnlineResource_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'applicationProfile'), CharacterString_PropertyType, scope=CI_OnlineResource_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 113, 5)))

CI_OnlineResource_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'name'), CharacterString_PropertyType, scope=CI_OnlineResource_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 114, 5)))

CI_OnlineResource_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'description'), CharacterString_PropertyType, scope=CI_OnlineResource_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 115, 5)))

CI_OnlineResource_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'function'), CI_OnLineFunctionCode_PropertyType, scope=CI_OnlineResource_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 116, 5)))

def _BuildAutomaton_59 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_59
    del _BuildAutomaton_59
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 112, 5))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 113, 5))
    counters.add(cc_1)
    cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 114, 5))
    counters.add(cc_2)
    cc_3 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 115, 5))
    counters.add(cc_3)
    cc_4 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 116, 5))
    counters.add(cc_4)
    states = []
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(CI_OnlineResource_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'linkage')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 111, 5))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(CI_OnlineResource_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'protocol')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 112, 5))
    st_1 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_1, False))
    symbol = pyxb.binding.content.ElementUse(CI_OnlineResource_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'applicationProfile')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 113, 5))
    st_2 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_2, False))
    symbol = pyxb.binding.content.ElementUse(CI_OnlineResource_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'name')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 114, 5))
    st_3 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_3)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_3, False))
    symbol = pyxb.binding.content.ElementUse(CI_OnlineResource_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'description')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 115, 5))
    st_4 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_4)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_4, False))
    symbol = pyxb.binding.content.ElementUse(CI_OnlineResource_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'function')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 116, 5))
    st_5 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_5)
    transitions = []
    transitions.append(fac.Transition(st_1, [
         ]))
    transitions.append(fac.Transition(st_2, [
         ]))
    transitions.append(fac.Transition(st_3, [
         ]))
    transitions.append(fac.Transition(st_4, [
         ]))
    transitions.append(fac.Transition(st_5, [
         ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_1, True) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_1, False) ]))
    st_2._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_2, True) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_2, False) ]))
    st_3._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_3, True) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_3, False) ]))
    st_4._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_4, True) ]))
    st_5._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
CI_OnlineResource_Type._Automaton = _BuildAutomaton_59()




CI_Contact_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'phone'), CI_Telephone_PropertyType, scope=CI_Contact_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 139, 5)))

CI_Contact_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'address'), CI_Address_PropertyType, scope=CI_Contact_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 140, 5)))

CI_Contact_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'onlineResource'), CI_OnlineResource_PropertyType, scope=CI_Contact_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 141, 5)))

CI_Contact_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'hoursOfService'), CharacterString_PropertyType, scope=CI_Contact_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 142, 5)))

CI_Contact_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'contactInstructions'), CharacterString_PropertyType, scope=CI_Contact_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 143, 5)))

def _BuildAutomaton_60 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_60
    del _BuildAutomaton_60
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 139, 5))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 140, 5))
    counters.add(cc_1)
    cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 141, 5))
    counters.add(cc_2)
    cc_3 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 142, 5))
    counters.add(cc_3)
    cc_4 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 143, 5))
    counters.add(cc_4)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(CI_Contact_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'phone')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 139, 5))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_1, False))
    symbol = pyxb.binding.content.ElementUse(CI_Contact_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'address')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 140, 5))
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_2, False))
    symbol = pyxb.binding.content.ElementUse(CI_Contact_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'onlineResource')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 141, 5))
    st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_3, False))
    symbol = pyxb.binding.content.ElementUse(CI_Contact_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'hoursOfService')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 142, 5))
    st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_3)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_4, False))
    symbol = pyxb.binding.content.ElementUse(CI_Contact_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'contactInstructions')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 143, 5))
    st_4 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_4)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_1, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_1, False) ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_2, True) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_2, False) ]))
    st_2._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_3, True) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_3, False) ]))
    st_3._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_4, True) ]))
    st_4._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
CI_Contact_Type._Automaton = _BuildAutomaton_60()




CI_Telephone_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'voice'), CharacterString_PropertyType, scope=CI_Telephone_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 166, 5)))

CI_Telephone_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'facsimile'), CharacterString_PropertyType, scope=CI_Telephone_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 167, 5)))

def _BuildAutomaton_61 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_61
    del _BuildAutomaton_61
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 166, 5))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 167, 5))
    counters.add(cc_1)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(CI_Telephone_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'voice')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 166, 5))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_1, False))
    symbol = pyxb.binding.content.ElementUse(CI_Telephone_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'facsimile')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 167, 5))
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_1, True) ]))
    st_1._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
CI_Telephone_Type._Automaton = _BuildAutomaton_61()




CI_Date_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'date'), Date_PropertyType, scope=CI_Date_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 187, 5)))

CI_Date_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'dateType'), CI_DateTypeCode_PropertyType, scope=CI_Date_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 188, 5)))

def _BuildAutomaton_62 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_62
    del _BuildAutomaton_62
    import pyxb.utils.fac as fac

    counters = set()
    states = []
    final_update = None
    symbol = pyxb.binding.content.ElementUse(CI_Date_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'date')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 187, 5))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(CI_Date_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'dateType')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 188, 5))
    st_1 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    transitions = []
    transitions.append(fac.Transition(st_1, [
         ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    st_1._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
CI_Date_Type._Automaton = _BuildAutomaton_62()




CI_Series_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'name'), CharacterString_PropertyType, scope=CI_Series_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 208, 5)))

CI_Series_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'issueIdentification'), CharacterString_PropertyType, scope=CI_Series_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 209, 5)))

CI_Series_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'page'), CharacterString_PropertyType, scope=CI_Series_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 210, 5)))

def _BuildAutomaton_63 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_63
    del _BuildAutomaton_63
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 208, 5))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 209, 5))
    counters.add(cc_1)
    cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 210, 5))
    counters.add(cc_2)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(CI_Series_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'name')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 208, 5))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_1, False))
    symbol = pyxb.binding.content.ElementUse(CI_Series_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'issueIdentification')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 209, 5))
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_2, False))
    symbol = pyxb.binding.content.ElementUse(CI_Series_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'page')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 210, 5))
    st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_1, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_1, False) ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_2, True) ]))
    st_2._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
CI_Series_Type._Automaton = _BuildAutomaton_63()




MD_Constraints_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'useLimitation'), CharacterString_PropertyType, scope=MD_Constraints_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/constraints.xsd', 20, 5)))

def _BuildAutomaton_64 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_64
    del _BuildAutomaton_64
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/constraints.xsd', 20, 5))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(MD_Constraints_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'useLimitation')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/constraints.xsd', 20, 5))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
MD_Constraints_Type._Automaton = _BuildAutomaton_64()




MD_RangeDimension_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'sequenceIdentifier'), MemberName_PropertyType, scope=MD_RangeDimension_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/content.xsd', 126, 5)))

MD_RangeDimension_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'descriptor'), CharacterString_PropertyType, scope=MD_RangeDimension_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/content.xsd', 127, 5)))

def _BuildAutomaton_65 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_65
    del _BuildAutomaton_65
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/content.xsd', 126, 5))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/content.xsd', 127, 5))
    counters.add(cc_1)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(MD_RangeDimension_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'sequenceIdentifier')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/content.xsd', 126, 5))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_1, False))
    symbol = pyxb.binding.content.ElementUse(MD_RangeDimension_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'descriptor')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/content.xsd', 127, 5))
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_1, True) ]))
    st_1._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
MD_RangeDimension_Type._Automaton = _BuildAutomaton_65()




LI_ProcessStep_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'description'), CharacterString_PropertyType, scope=LI_ProcessStep_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 19, 5)))

LI_ProcessStep_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'rationale'), CharacterString_PropertyType, scope=LI_ProcessStep_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 20, 5)))

LI_ProcessStep_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'dateTime'), DateTime_PropertyType, scope=LI_ProcessStep_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 21, 5)))

LI_ProcessStep_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'processor'), CI_ResponsibleParty_PropertyType, scope=LI_ProcessStep_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 22, 5)))

LI_ProcessStep_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'source'), LI_Source_PropertyType, scope=LI_ProcessStep_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 23, 5)))

def _BuildAutomaton_66 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_66
    del _BuildAutomaton_66
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 20, 5))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 21, 5))
    counters.add(cc_1)
    cc_2 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 22, 5))
    counters.add(cc_2)
    cc_3 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 23, 5))
    counters.add(cc_3)
    states = []
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(LI_ProcessStep_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'description')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 19, 5))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(LI_ProcessStep_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'rationale')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 20, 5))
    st_1 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_1, False))
    symbol = pyxb.binding.content.ElementUse(LI_ProcessStep_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'dateTime')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 21, 5))
    st_2 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_2, False))
    symbol = pyxb.binding.content.ElementUse(LI_ProcessStep_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'processor')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 22, 5))
    st_3 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_3)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_3, False))
    symbol = pyxb.binding.content.ElementUse(LI_ProcessStep_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'source')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 23, 5))
    st_4 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_4)
    transitions = []
    transitions.append(fac.Transition(st_1, [
         ]))
    transitions.append(fac.Transition(st_2, [
         ]))
    transitions.append(fac.Transition(st_3, [
         ]))
    transitions.append(fac.Transition(st_4, [
         ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_1, True) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_1, False) ]))
    st_2._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_2, True) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_2, False) ]))
    st_3._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_3, True) ]))
    st_4._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
LI_ProcessStep_Type._Automaton = _BuildAutomaton_66()




LI_Source_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'description'), CharacterString_PropertyType, scope=LI_Source_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 43, 5)))

LI_Source_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'scaleDenominator'), MD_RepresentativeFraction_PropertyType, scope=LI_Source_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 44, 5)))

LI_Source_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'sourceReferenceSystem'), MD_ReferenceSystem_PropertyType, scope=LI_Source_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 45, 5)))

LI_Source_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'sourceCitation'), CI_Citation_PropertyType, scope=LI_Source_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 46, 5)))

LI_Source_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'sourceExtent'), EX_Extent_PropertyType, scope=LI_Source_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 47, 5)))

LI_Source_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'sourceStep'), LI_ProcessStep_PropertyType, scope=LI_Source_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 48, 5)))

def _BuildAutomaton_67 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_67
    del _BuildAutomaton_67
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 43, 5))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 44, 5))
    counters.add(cc_1)
    cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 45, 5))
    counters.add(cc_2)
    cc_3 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 46, 5))
    counters.add(cc_3)
    cc_4 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 47, 5))
    counters.add(cc_4)
    cc_5 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 48, 5))
    counters.add(cc_5)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(LI_Source_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'description')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 43, 5))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_1, False))
    symbol = pyxb.binding.content.ElementUse(LI_Source_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'scaleDenominator')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 44, 5))
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_2, False))
    symbol = pyxb.binding.content.ElementUse(LI_Source_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'sourceReferenceSystem')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 45, 5))
    st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_3, False))
    symbol = pyxb.binding.content.ElementUse(LI_Source_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'sourceCitation')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 46, 5))
    st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_3)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_4, False))
    symbol = pyxb.binding.content.ElementUse(LI_Source_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'sourceExtent')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 47, 5))
    st_4 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_4)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_5, False))
    symbol = pyxb.binding.content.ElementUse(LI_Source_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'sourceStep')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 48, 5))
    st_5 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_5)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_1, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_1, False) ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_2, True) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_2, False) ]))
    st_2._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_3, True) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_3, False) ]))
    st_3._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_4, True) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_4, False) ]))
    st_4._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_5, True) ]))
    st_5._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
LI_Source_Type._Automaton = _BuildAutomaton_67()




LI_Lineage_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'statement'), CharacterString_PropertyType, scope=LI_Lineage_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 68, 5)))

LI_Lineage_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'processStep'), LI_ProcessStep_PropertyType, scope=LI_Lineage_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 69, 5)))

LI_Lineage_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'source'), LI_Source_PropertyType, scope=LI_Lineage_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 70, 5)))

def _BuildAutomaton_68 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_68
    del _BuildAutomaton_68
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 68, 5))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 69, 5))
    counters.add(cc_1)
    cc_2 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 70, 5))
    counters.add(cc_2)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(LI_Lineage_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'statement')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 68, 5))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_1, False))
    symbol = pyxb.binding.content.ElementUse(LI_Lineage_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'processStep')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 69, 5))
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_2, False))
    symbol = pyxb.binding.content.ElementUse(LI_Lineage_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'source')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 70, 5))
    st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_1, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_1, False) ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_2, True) ]))
    st_2._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
LI_Lineage_Type._Automaton = _BuildAutomaton_68()




AbstractDQ_Element_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'nameOfMeasure'), CharacterString_PropertyType, scope=AbstractDQ_Element_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 479, 5)))

AbstractDQ_Element_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'measureIdentification'), MD_Identifier_PropertyType, scope=AbstractDQ_Element_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 480, 5)))

AbstractDQ_Element_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'measureDescription'), CharacterString_PropertyType, scope=AbstractDQ_Element_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 481, 5)))

AbstractDQ_Element_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'evaluationMethodType'), DQ_EvaluationMethodTypeCode_PropertyType, scope=AbstractDQ_Element_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 482, 5)))

AbstractDQ_Element_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'evaluationMethodDescription'), CharacterString_PropertyType, scope=AbstractDQ_Element_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 483, 5)))

AbstractDQ_Element_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'evaluationProcedure'), CI_Citation_PropertyType, scope=AbstractDQ_Element_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 484, 5)))

AbstractDQ_Element_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'dateTime'), DateTime_PropertyType, scope=AbstractDQ_Element_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 485, 5)))

AbstractDQ_Element_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'result'), DQ_Result_PropertyType, scope=AbstractDQ_Element_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 486, 5)))

def _BuildAutomaton_69 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_69
    del _BuildAutomaton_69
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 479, 5))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 480, 5))
    counters.add(cc_1)
    cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 481, 5))
    counters.add(cc_2)
    cc_3 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 482, 5))
    counters.add(cc_3)
    cc_4 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 483, 5))
    counters.add(cc_4)
    cc_5 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 484, 5))
    counters.add(cc_5)
    cc_6 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 485, 5))
    counters.add(cc_6)
    cc_7 = fac.CounterCondition(min=1, max=2, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 486, 5))
    counters.add(cc_7)
    states = []
    final_update = None
    symbol = pyxb.binding.content.ElementUse(AbstractDQ_Element_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'nameOfMeasure')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 479, 5))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(AbstractDQ_Element_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'measureIdentification')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 480, 5))
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(AbstractDQ_Element_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'measureDescription')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 481, 5))
    st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(AbstractDQ_Element_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'evaluationMethodType')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 482, 5))
    st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_3)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(AbstractDQ_Element_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'evaluationMethodDescription')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 483, 5))
    st_4 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_4)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(AbstractDQ_Element_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'evaluationProcedure')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 484, 5))
    st_5 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_5)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(AbstractDQ_Element_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'dateTime')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 485, 5))
    st_6 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_6)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_7, False))
    symbol = pyxb.binding.content.ElementUse(AbstractDQ_Element_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'result')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 486, 5))
    st_7 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_7)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_1, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_1, False) ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_2, True) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_2, False) ]))
    st_2._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_3, True) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_3, False) ]))
    st_3._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_4, True) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_4, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_4, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_4, False) ]))
    st_4._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_5, True) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_5, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_5, False) ]))
    st_5._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_6, True) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_6, False) ]))
    st_6._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_7, True) ]))
    st_7._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
AbstractDQ_Element_Type._Automaton = _BuildAutomaton_69()




DQ_DataQuality_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'scope'), DQ_Scope_PropertyType, scope=DQ_DataQuality_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 506, 5)))

DQ_DataQuality_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'report'), DQ_Element_PropertyType, scope=DQ_DataQuality_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 507, 5)))

DQ_DataQuality_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'lineage'), LI_Lineage_PropertyType, scope=DQ_DataQuality_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 508, 5)))

def _BuildAutomaton_70 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_70
    del _BuildAutomaton_70
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 507, 5))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 508, 5))
    counters.add(cc_1)
    states = []
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(DQ_DataQuality_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'scope')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 506, 5))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(DQ_DataQuality_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'report')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 507, 5))
    st_1 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_1, False))
    symbol = pyxb.binding.content.ElementUse(DQ_DataQuality_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'lineage')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 508, 5))
    st_2 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    transitions = []
    transitions.append(fac.Transition(st_1, [
         ]))
    transitions.append(fac.Transition(st_2, [
         ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_1, True) ]))
    st_2._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
DQ_DataQuality_Type._Automaton = _BuildAutomaton_70()




DQ_Scope_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'level'), MD_ScopeCode_PropertyType, scope=DQ_Scope_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 528, 5)))

DQ_Scope_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'extent'), EX_Extent_PropertyType, scope=DQ_Scope_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 529, 5)))

DQ_Scope_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'levelDescription'), MD_ScopeDescription_PropertyType, scope=DQ_Scope_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 530, 5)))

def _BuildAutomaton_71 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_71
    del _BuildAutomaton_71
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 529, 5))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 530, 5))
    counters.add(cc_1)
    states = []
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(DQ_Scope_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'level')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 528, 5))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(DQ_Scope_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'extent')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 529, 5))
    st_1 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_1, False))
    symbol = pyxb.binding.content.ElementUse(DQ_Scope_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'levelDescription')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 530, 5))
    st_2 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    transitions = []
    transitions.append(fac.Transition(st_1, [
         ]))
    transitions.append(fac.Transition(st_2, [
         ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_1, True) ]))
    st_2._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
DQ_Scope_Type._Automaton = _BuildAutomaton_71()




MD_Medium_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'name'), MD_MediumNameCode_PropertyType, scope=MD_Medium_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/distribution.xsd', 21, 5)))

MD_Medium_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'density'), Real_PropertyType, scope=MD_Medium_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/distribution.xsd', 22, 5)))

MD_Medium_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'densityUnits'), CharacterString_PropertyType, scope=MD_Medium_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/distribution.xsd', 23, 5)))

MD_Medium_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'volumes'), Integer_PropertyType, scope=MD_Medium_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/distribution.xsd', 24, 5)))

MD_Medium_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'mediumFormat'), MD_MediumFormatCode_PropertyType, scope=MD_Medium_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/distribution.xsd', 25, 5)))

MD_Medium_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'mediumNote'), CharacterString_PropertyType, scope=MD_Medium_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/distribution.xsd', 26, 5)))

def _BuildAutomaton_72 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_72
    del _BuildAutomaton_72
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/distribution.xsd', 21, 5))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/distribution.xsd', 22, 5))
    counters.add(cc_1)
    cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/distribution.xsd', 23, 5))
    counters.add(cc_2)
    cc_3 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/distribution.xsd', 24, 5))
    counters.add(cc_3)
    cc_4 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/distribution.xsd', 25, 5))
    counters.add(cc_4)
    cc_5 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/distribution.xsd', 26, 5))
    counters.add(cc_5)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(MD_Medium_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'name')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/distribution.xsd', 21, 5))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_1, False))
    symbol = pyxb.binding.content.ElementUse(MD_Medium_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'density')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/distribution.xsd', 22, 5))
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_2, False))
    symbol = pyxb.binding.content.ElementUse(MD_Medium_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'densityUnits')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/distribution.xsd', 23, 5))
    st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_3, False))
    symbol = pyxb.binding.content.ElementUse(MD_Medium_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'volumes')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/distribution.xsd', 24, 5))
    st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_3)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_4, False))
    symbol = pyxb.binding.content.ElementUse(MD_Medium_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'mediumFormat')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/distribution.xsd', 25, 5))
    st_4 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_4)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_5, False))
    symbol = pyxb.binding.content.ElementUse(MD_Medium_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'mediumNote')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/distribution.xsd', 26, 5))
    st_5 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_5)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_1, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_1, False) ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_2, True) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_2, False) ]))
    st_2._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_3, True) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_3, False) ]))
    st_3._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_4, True) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_4, False) ]))
    st_4._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_5, True) ]))
    st_5._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
MD_Medium_Type._Automaton = _BuildAutomaton_72()




MD_DigitalTransferOptions_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'unitsOfDistribution'), CharacterString_PropertyType, scope=MD_DigitalTransferOptions_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/distribution.xsd', 49, 5)))

MD_DigitalTransferOptions_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'transferSize'), Real_PropertyType, scope=MD_DigitalTransferOptions_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/distribution.xsd', 50, 5)))

MD_DigitalTransferOptions_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'onLine'), CI_OnlineResource_PropertyType, scope=MD_DigitalTransferOptions_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/distribution.xsd', 51, 5)))

MD_DigitalTransferOptions_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'offLine'), MD_Medium_PropertyType, scope=MD_DigitalTransferOptions_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/distribution.xsd', 52, 5)))

def _BuildAutomaton_73 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_73
    del _BuildAutomaton_73
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/distribution.xsd', 49, 5))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/distribution.xsd', 50, 5))
    counters.add(cc_1)
    cc_2 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/distribution.xsd', 51, 5))
    counters.add(cc_2)
    cc_3 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/distribution.xsd', 52, 5))
    counters.add(cc_3)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(MD_DigitalTransferOptions_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'unitsOfDistribution')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/distribution.xsd', 49, 5))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_1, False))
    symbol = pyxb.binding.content.ElementUse(MD_DigitalTransferOptions_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'transferSize')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/distribution.xsd', 50, 5))
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_2, False))
    symbol = pyxb.binding.content.ElementUse(MD_DigitalTransferOptions_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'onLine')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/distribution.xsd', 51, 5))
    st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_3, False))
    symbol = pyxb.binding.content.ElementUse(MD_DigitalTransferOptions_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'offLine')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/distribution.xsd', 52, 5))
    st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_3)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_1, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_1, False) ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_2, True) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_2, False) ]))
    st_2._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_3, True) ]))
    st_3._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
MD_DigitalTransferOptions_Type._Automaton = _BuildAutomaton_73()




MD_StandardOrderProcess_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'fees'), CharacterString_PropertyType, scope=MD_StandardOrderProcess_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/distribution.xsd', 75, 5)))

MD_StandardOrderProcess_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'plannedAvailableDateTime'), DateTime_PropertyType, scope=MD_StandardOrderProcess_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/distribution.xsd', 76, 5)))

MD_StandardOrderProcess_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'orderingInstructions'), CharacterString_PropertyType, scope=MD_StandardOrderProcess_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/distribution.xsd', 77, 5)))

MD_StandardOrderProcess_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'turnaround'), CharacterString_PropertyType, scope=MD_StandardOrderProcess_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/distribution.xsd', 78, 5)))

def _BuildAutomaton_74 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_74
    del _BuildAutomaton_74
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/distribution.xsd', 75, 5))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/distribution.xsd', 76, 5))
    counters.add(cc_1)
    cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/distribution.xsd', 77, 5))
    counters.add(cc_2)
    cc_3 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/distribution.xsd', 78, 5))
    counters.add(cc_3)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(MD_StandardOrderProcess_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'fees')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/distribution.xsd', 75, 5))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_1, False))
    symbol = pyxb.binding.content.ElementUse(MD_StandardOrderProcess_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'plannedAvailableDateTime')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/distribution.xsd', 76, 5))
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_2, False))
    symbol = pyxb.binding.content.ElementUse(MD_StandardOrderProcess_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'orderingInstructions')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/distribution.xsd', 77, 5))
    st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_3, False))
    symbol = pyxb.binding.content.ElementUse(MD_StandardOrderProcess_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'turnaround')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/distribution.xsd', 78, 5))
    st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_3)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_1, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_1, False) ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_2, True) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_2, False) ]))
    st_2._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_3, True) ]))
    st_3._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
MD_StandardOrderProcess_Type._Automaton = _BuildAutomaton_74()




MD_Distributor_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'distributorContact'), CI_ResponsibleParty_PropertyType, scope=MD_Distributor_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/distribution.xsd', 101, 5)))

MD_Distributor_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'distributionOrderProcess'), MD_StandardOrderProcess_PropertyType, scope=MD_Distributor_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/distribution.xsd', 102, 5)))

MD_Distributor_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'distributorFormat'), MD_Format_PropertyType, scope=MD_Distributor_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/distribution.xsd', 103, 5)))

MD_Distributor_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'distributorTransferOptions'), MD_DigitalTransferOptions_PropertyType, scope=MD_Distributor_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/distribution.xsd', 104, 5)))

def _BuildAutomaton_75 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_75
    del _BuildAutomaton_75
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/distribution.xsd', 102, 5))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/distribution.xsd', 103, 5))
    counters.add(cc_1)
    cc_2 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/distribution.xsd', 104, 5))
    counters.add(cc_2)
    states = []
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(MD_Distributor_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'distributorContact')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/distribution.xsd', 101, 5))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(MD_Distributor_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'distributionOrderProcess')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/distribution.xsd', 102, 5))
    st_1 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_1, False))
    symbol = pyxb.binding.content.ElementUse(MD_Distributor_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'distributorFormat')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/distribution.xsd', 103, 5))
    st_2 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_2, False))
    symbol = pyxb.binding.content.ElementUse(MD_Distributor_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'distributorTransferOptions')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/distribution.xsd', 104, 5))
    st_3 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_3)
    transitions = []
    transitions.append(fac.Transition(st_1, [
         ]))
    transitions.append(fac.Transition(st_2, [
         ]))
    transitions.append(fac.Transition(st_3, [
         ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_1, True) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_1, False) ]))
    st_2._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_2, True) ]))
    st_3._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
MD_Distributor_Type._Automaton = _BuildAutomaton_75()




MD_Distribution_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'distributionFormat'), MD_Format_PropertyType, scope=MD_Distribution_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/distribution.xsd', 127, 5)))

MD_Distribution_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'distributor'), MD_Distributor_PropertyType, scope=MD_Distribution_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/distribution.xsd', 128, 5)))

MD_Distribution_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'transferOptions'), MD_DigitalTransferOptions_PropertyType, scope=MD_Distribution_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/distribution.xsd', 129, 5)))

def _BuildAutomaton_76 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_76
    del _BuildAutomaton_76
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/distribution.xsd', 127, 5))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/distribution.xsd', 128, 5))
    counters.add(cc_1)
    cc_2 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/distribution.xsd', 129, 5))
    counters.add(cc_2)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(MD_Distribution_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'distributionFormat')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/distribution.xsd', 127, 5))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_1, False))
    symbol = pyxb.binding.content.ElementUse(MD_Distribution_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'distributor')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/distribution.xsd', 128, 5))
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_2, False))
    symbol = pyxb.binding.content.ElementUse(MD_Distribution_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'transferOptions')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/distribution.xsd', 129, 5))
    st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_1, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_1, False) ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_2, True) ]))
    st_2._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
MD_Distribution_Type._Automaton = _BuildAutomaton_76()




MD_Format_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'name'), CharacterString_PropertyType, scope=MD_Format_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/distribution.xsd', 152, 5)))

MD_Format_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'version'), CharacterString_PropertyType, scope=MD_Format_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/distribution.xsd', 153, 5)))

MD_Format_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'amendmentNumber'), CharacterString_PropertyType, scope=MD_Format_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/distribution.xsd', 154, 5)))

MD_Format_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'specification'), CharacterString_PropertyType, scope=MD_Format_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/distribution.xsd', 155, 5)))

MD_Format_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'fileDecompressionTechnique'), CharacterString_PropertyType, scope=MD_Format_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/distribution.xsd', 156, 5)))

MD_Format_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'formatDistributor'), MD_Distributor_PropertyType, scope=MD_Format_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/distribution.xsd', 157, 5)))

def _BuildAutomaton_77 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_77
    del _BuildAutomaton_77
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/distribution.xsd', 154, 5))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/distribution.xsd', 155, 5))
    counters.add(cc_1)
    cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/distribution.xsd', 156, 5))
    counters.add(cc_2)
    cc_3 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/distribution.xsd', 157, 5))
    counters.add(cc_3)
    states = []
    final_update = None
    symbol = pyxb.binding.content.ElementUse(MD_Format_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'name')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/distribution.xsd', 152, 5))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(MD_Format_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'version')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/distribution.xsd', 153, 5))
    st_1 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(MD_Format_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'amendmentNumber')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/distribution.xsd', 154, 5))
    st_2 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_1, False))
    symbol = pyxb.binding.content.ElementUse(MD_Format_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'specification')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/distribution.xsd', 155, 5))
    st_3 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_3)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_2, False))
    symbol = pyxb.binding.content.ElementUse(MD_Format_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'fileDecompressionTechnique')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/distribution.xsd', 156, 5))
    st_4 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_4)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_3, False))
    symbol = pyxb.binding.content.ElementUse(MD_Format_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'formatDistributor')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/distribution.xsd', 157, 5))
    st_5 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_5)
    transitions = []
    transitions.append(fac.Transition(st_1, [
         ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_2, [
         ]))
    transitions.append(fac.Transition(st_3, [
         ]))
    transitions.append(fac.Transition(st_4, [
         ]))
    transitions.append(fac.Transition(st_5, [
         ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_2._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_1, True) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_1, False) ]))
    st_3._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_2, True) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_2, False) ]))
    st_4._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_3, True) ]))
    st_5._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
MD_Format_Type._Automaton = _BuildAutomaton_77()




EX_TemporalExtent_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'extent'), TM_Primitive_PropertyType, scope=EX_TemporalExtent_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/extent.xsd', 24, 5)))

def _BuildAutomaton_78 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_78
    del _BuildAutomaton_78
    import pyxb.utils.fac as fac

    counters = set()
    states = []
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(EX_TemporalExtent_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'extent')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/extent.xsd', 24, 5))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
EX_TemporalExtent_Type._Automaton = _BuildAutomaton_78()




EX_VerticalExtent_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'minimumValue'), Real_PropertyType, scope=EX_VerticalExtent_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/extent.xsd', 47, 5)))

EX_VerticalExtent_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'maximumValue'), Real_PropertyType, scope=EX_VerticalExtent_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/extent.xsd', 48, 5)))

EX_VerticalExtent_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'verticalCRS'), SC_CRS_PropertyType, scope=EX_VerticalExtent_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/extent.xsd', 49, 5)))

def _BuildAutomaton_79 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_79
    del _BuildAutomaton_79
    import pyxb.utils.fac as fac

    counters = set()
    states = []
    final_update = None
    symbol = pyxb.binding.content.ElementUse(EX_VerticalExtent_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'minimumValue')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/extent.xsd', 47, 5))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(EX_VerticalExtent_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'maximumValue')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/extent.xsd', 48, 5))
    st_1 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(EX_VerticalExtent_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'verticalCRS')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/extent.xsd', 49, 5))
    st_2 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    transitions = []
    transitions.append(fac.Transition(st_1, [
         ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_2, [
         ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    st_2._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
EX_VerticalExtent_Type._Automaton = _BuildAutomaton_79()




EX_Extent_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'description'), CharacterString_PropertyType, scope=EX_Extent_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/extent.xsd', 95, 5)))

EX_Extent_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'geographicElement'), EX_GeographicExtent_PropertyType, scope=EX_Extent_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/extent.xsd', 96, 5)))

EX_Extent_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'temporalElement'), EX_TemporalExtent_PropertyType, scope=EX_Extent_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/extent.xsd', 97, 5)))

EX_Extent_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'verticalElement'), EX_VerticalExtent_PropertyType, scope=EX_Extent_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/extent.xsd', 98, 5)))

def _BuildAutomaton_80 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_80
    del _BuildAutomaton_80
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/extent.xsd', 95, 5))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/extent.xsd', 96, 5))
    counters.add(cc_1)
    cc_2 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/extent.xsd', 97, 5))
    counters.add(cc_2)
    cc_3 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/extent.xsd', 98, 5))
    counters.add(cc_3)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(EX_Extent_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'description')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/extent.xsd', 95, 5))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_1, False))
    symbol = pyxb.binding.content.ElementUse(EX_Extent_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'geographicElement')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/extent.xsd', 96, 5))
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_2, False))
    symbol = pyxb.binding.content.ElementUse(EX_Extent_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'temporalElement')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/extent.xsd', 97, 5))
    st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_3, False))
    symbol = pyxb.binding.content.ElementUse(EX_Extent_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'verticalElement')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/extent.xsd', 98, 5))
    st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_3)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_1, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_1, False) ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_2, True) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_2, False) ]))
    st_2._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_3, True) ]))
    st_3._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
EX_Extent_Type._Automaton = _BuildAutomaton_80()




AbstractEX_GeographicExtent_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'extentTypeCode'), Boolean_PropertyType, scope=AbstractEX_GeographicExtent_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/extent.xsd', 121, 5)))

def _BuildAutomaton_81 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_81
    del _BuildAutomaton_81
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/extent.xsd', 121, 5))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(AbstractEX_GeographicExtent_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'extentTypeCode')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/extent.xsd', 121, 5))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
AbstractEX_GeographicExtent_Type._Automaton = _BuildAutomaton_81()




PT_FreeText_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'textGroup'), LocalisedCharacterString_PropertyType, scope=PT_FreeText_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/freeText.xsd', 18, 5)))

def _BuildAutomaton_82 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_82
    del _BuildAutomaton_82
    import pyxb.utils.fac as fac

    counters = set()
    states = []
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(PT_FreeText_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'textGroup')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/freeText.xsd', 18, 5))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
         ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
PT_FreeText_Type._Automaton = _BuildAutomaton_82()




PT_Locale_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'languageCode'), LanguageCode_PropertyType, scope=PT_Locale_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/freeText.xsd', 40, 5)))

PT_Locale_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'country'), Country_PropertyType, scope=PT_Locale_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/freeText.xsd', 41, 5)))

PT_Locale_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'characterEncoding'), MD_CharacterSetCode_PropertyType, scope=PT_Locale_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/freeText.xsd', 42, 5)))

def _BuildAutomaton_83 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_83
    del _BuildAutomaton_83
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/freeText.xsd', 41, 5))
    counters.add(cc_0)
    states = []
    final_update = None
    symbol = pyxb.binding.content.ElementUse(PT_Locale_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'languageCode')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/freeText.xsd', 40, 5))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(PT_Locale_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'country')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/freeText.xsd', 41, 5))
    st_1 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(PT_Locale_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'characterEncoding')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/freeText.xsd', 42, 5))
    st_2 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    transitions = []
    transitions.append(fac.Transition(st_1, [
         ]))
    transitions.append(fac.Transition(st_2, [
         ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    st_2._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
PT_Locale_Type._Automaton = _BuildAutomaton_83()




AbstractMD_Identification_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'citation'), CI_Citation_PropertyType, scope=AbstractMD_Identification_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 23, 5)))

AbstractMD_Identification_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'abstract'), CharacterString_PropertyType, scope=AbstractMD_Identification_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 24, 5)))

AbstractMD_Identification_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'purpose'), CharacterString_PropertyType, scope=AbstractMD_Identification_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 25, 5)))

AbstractMD_Identification_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'credit'), CharacterString_PropertyType, scope=AbstractMD_Identification_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 26, 5)))

AbstractMD_Identification_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'status'), MD_ProgressCode_PropertyType, scope=AbstractMD_Identification_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 27, 5)))

AbstractMD_Identification_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'pointOfContact'), CI_ResponsibleParty_PropertyType, scope=AbstractMD_Identification_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 28, 5)))

AbstractMD_Identification_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'resourceMaintenance'), MD_MaintenanceInformation_PropertyType, scope=AbstractMD_Identification_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 29, 5)))

AbstractMD_Identification_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'graphicOverview'), MD_BrowseGraphic_PropertyType, scope=AbstractMD_Identification_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 30, 5)))

AbstractMD_Identification_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'resourceFormat'), MD_Format_PropertyType, scope=AbstractMD_Identification_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 31, 5)))

AbstractMD_Identification_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'descriptiveKeywords'), MD_Keywords_PropertyType, scope=AbstractMD_Identification_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 32, 5)))

AbstractMD_Identification_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'resourceSpecificUsage'), MD_Usage_PropertyType, scope=AbstractMD_Identification_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 33, 5)))

AbstractMD_Identification_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'resourceConstraints'), MD_Constraints_PropertyType, scope=AbstractMD_Identification_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 34, 5)))

AbstractMD_Identification_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'aggregationInfo'), MD_AggregateInformation_PropertyType, scope=AbstractMD_Identification_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 35, 5)))

def _BuildAutomaton_84 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_84
    del _BuildAutomaton_84
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 25, 5))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 26, 5))
    counters.add(cc_1)
    cc_2 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 27, 5))
    counters.add(cc_2)
    cc_3 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 28, 5))
    counters.add(cc_3)
    cc_4 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 29, 5))
    counters.add(cc_4)
    cc_5 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 30, 5))
    counters.add(cc_5)
    cc_6 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 31, 5))
    counters.add(cc_6)
    cc_7 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 32, 5))
    counters.add(cc_7)
    cc_8 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 33, 5))
    counters.add(cc_8)
    cc_9 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 34, 5))
    counters.add(cc_9)
    cc_10 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 35, 5))
    counters.add(cc_10)
    states = []
    final_update = None
    symbol = pyxb.binding.content.ElementUse(AbstractMD_Identification_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'citation')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 23, 5))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(AbstractMD_Identification_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'abstract')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 24, 5))
    st_1 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(AbstractMD_Identification_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'purpose')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 25, 5))
    st_2 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_1, False))
    symbol = pyxb.binding.content.ElementUse(AbstractMD_Identification_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'credit')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 26, 5))
    st_3 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_3)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_2, False))
    symbol = pyxb.binding.content.ElementUse(AbstractMD_Identification_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'status')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 27, 5))
    st_4 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_4)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_3, False))
    symbol = pyxb.binding.content.ElementUse(AbstractMD_Identification_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'pointOfContact')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 28, 5))
    st_5 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_5)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_4, False))
    symbol = pyxb.binding.content.ElementUse(AbstractMD_Identification_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'resourceMaintenance')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 29, 5))
    st_6 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_6)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_5, False))
    symbol = pyxb.binding.content.ElementUse(AbstractMD_Identification_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'graphicOverview')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 30, 5))
    st_7 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_7)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_6, False))
    symbol = pyxb.binding.content.ElementUse(AbstractMD_Identification_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'resourceFormat')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 31, 5))
    st_8 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_8)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_7, False))
    symbol = pyxb.binding.content.ElementUse(AbstractMD_Identification_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'descriptiveKeywords')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 32, 5))
    st_9 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_9)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_8, False))
    symbol = pyxb.binding.content.ElementUse(AbstractMD_Identification_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'resourceSpecificUsage')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 33, 5))
    st_10 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_10)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_9, False))
    symbol = pyxb.binding.content.ElementUse(AbstractMD_Identification_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'resourceConstraints')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 34, 5))
    st_11 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_11)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_10, False))
    symbol = pyxb.binding.content.ElementUse(AbstractMD_Identification_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'aggregationInfo')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 35, 5))
    st_12 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_12)
    transitions = []
    transitions.append(fac.Transition(st_1, [
         ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_2, [
         ]))
    transitions.append(fac.Transition(st_3, [
         ]))
    transitions.append(fac.Transition(st_4, [
         ]))
    transitions.append(fac.Transition(st_5, [
         ]))
    transitions.append(fac.Transition(st_6, [
         ]))
    transitions.append(fac.Transition(st_7, [
         ]))
    transitions.append(fac.Transition(st_8, [
         ]))
    transitions.append(fac.Transition(st_9, [
         ]))
    transitions.append(fac.Transition(st_10, [
         ]))
    transitions.append(fac.Transition(st_11, [
         ]))
    transitions.append(fac.Transition(st_12, [
         ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_8, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_9, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_10, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_11, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_12, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_2._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_1, True) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_8, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_9, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_10, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_11, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_12, [
        fac.UpdateInstruction(cc_1, False) ]))
    st_3._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_2, True) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_8, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_9, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_10, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_11, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_12, [
        fac.UpdateInstruction(cc_2, False) ]))
    st_4._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_3, True) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_8, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_9, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_10, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_11, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_12, [
        fac.UpdateInstruction(cc_3, False) ]))
    st_5._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_4, True) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_4, False) ]))
    transitions.append(fac.Transition(st_8, [
        fac.UpdateInstruction(cc_4, False) ]))
    transitions.append(fac.Transition(st_9, [
        fac.UpdateInstruction(cc_4, False) ]))
    transitions.append(fac.Transition(st_10, [
        fac.UpdateInstruction(cc_4, False) ]))
    transitions.append(fac.Transition(st_11, [
        fac.UpdateInstruction(cc_4, False) ]))
    transitions.append(fac.Transition(st_12, [
        fac.UpdateInstruction(cc_4, False) ]))
    st_6._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_5, True) ]))
    transitions.append(fac.Transition(st_8, [
        fac.UpdateInstruction(cc_5, False) ]))
    transitions.append(fac.Transition(st_9, [
        fac.UpdateInstruction(cc_5, False) ]))
    transitions.append(fac.Transition(st_10, [
        fac.UpdateInstruction(cc_5, False) ]))
    transitions.append(fac.Transition(st_11, [
        fac.UpdateInstruction(cc_5, False) ]))
    transitions.append(fac.Transition(st_12, [
        fac.UpdateInstruction(cc_5, False) ]))
    st_7._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_8, [
        fac.UpdateInstruction(cc_6, True) ]))
    transitions.append(fac.Transition(st_9, [
        fac.UpdateInstruction(cc_6, False) ]))
    transitions.append(fac.Transition(st_10, [
        fac.UpdateInstruction(cc_6, False) ]))
    transitions.append(fac.Transition(st_11, [
        fac.UpdateInstruction(cc_6, False) ]))
    transitions.append(fac.Transition(st_12, [
        fac.UpdateInstruction(cc_6, False) ]))
    st_8._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_9, [
        fac.UpdateInstruction(cc_7, True) ]))
    transitions.append(fac.Transition(st_10, [
        fac.UpdateInstruction(cc_7, False) ]))
    transitions.append(fac.Transition(st_11, [
        fac.UpdateInstruction(cc_7, False) ]))
    transitions.append(fac.Transition(st_12, [
        fac.UpdateInstruction(cc_7, False) ]))
    st_9._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_10, [
        fac.UpdateInstruction(cc_8, True) ]))
    transitions.append(fac.Transition(st_11, [
        fac.UpdateInstruction(cc_8, False) ]))
    transitions.append(fac.Transition(st_12, [
        fac.UpdateInstruction(cc_8, False) ]))
    st_10._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_11, [
        fac.UpdateInstruction(cc_9, True) ]))
    transitions.append(fac.Transition(st_12, [
        fac.UpdateInstruction(cc_9, False) ]))
    st_11._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_12, [
        fac.UpdateInstruction(cc_10, True) ]))
    st_12._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
AbstractMD_Identification_Type._Automaton = _BuildAutomaton_84()




MD_BrowseGraphic_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'fileName'), CharacterString_PropertyType, scope=MD_BrowseGraphic_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 58, 5)))

MD_BrowseGraphic_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'fileDescription'), CharacterString_PropertyType, scope=MD_BrowseGraphic_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 59, 5)))

MD_BrowseGraphic_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'fileType'), CharacterString_PropertyType, scope=MD_BrowseGraphic_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 60, 5)))

def _BuildAutomaton_85 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_85
    del _BuildAutomaton_85
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 59, 5))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 60, 5))
    counters.add(cc_1)
    states = []
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(MD_BrowseGraphic_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'fileName')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 58, 5))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(MD_BrowseGraphic_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'fileDescription')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 59, 5))
    st_1 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_1, False))
    symbol = pyxb.binding.content.ElementUse(MD_BrowseGraphic_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'fileType')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 60, 5))
    st_2 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    transitions = []
    transitions.append(fac.Transition(st_1, [
         ]))
    transitions.append(fac.Transition(st_2, [
         ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_1, True) ]))
    st_2._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
MD_BrowseGraphic_Type._Automaton = _BuildAutomaton_85()




MD_RepresentativeFraction_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'denominator'), Integer_PropertyType, scope=MD_RepresentativeFraction_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 126, 5)))

def _BuildAutomaton_86 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_86
    del _BuildAutomaton_86
    import pyxb.utils.fac as fac

    counters = set()
    states = []
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(MD_RepresentativeFraction_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'denominator')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 126, 5))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
MD_RepresentativeFraction_Type._Automaton = _BuildAutomaton_86()




MD_Usage_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'specificUsage'), CharacterString_PropertyType, scope=MD_Usage_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 149, 5)))

MD_Usage_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'usageDateTime'), DateTime_PropertyType, scope=MD_Usage_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 150, 5)))

MD_Usage_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'userDeterminedLimitations'), CharacterString_PropertyType, scope=MD_Usage_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 151, 5)))

MD_Usage_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'userContactInfo'), CI_ResponsibleParty_PropertyType, scope=MD_Usage_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 152, 5)))

def _BuildAutomaton_87 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_87
    del _BuildAutomaton_87
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 150, 5))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 151, 5))
    counters.add(cc_1)
    states = []
    final_update = None
    symbol = pyxb.binding.content.ElementUse(MD_Usage_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'specificUsage')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 149, 5))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(MD_Usage_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'usageDateTime')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 150, 5))
    st_1 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(MD_Usage_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'userDeterminedLimitations')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 151, 5))
    st_2 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(MD_Usage_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'userContactInfo')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 152, 5))
    st_3 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_3)
    transitions = []
    transitions.append(fac.Transition(st_1, [
         ]))
    transitions.append(fac.Transition(st_2, [
         ]))
    transitions.append(fac.Transition(st_3, [
         ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_1, True) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_1, False) ]))
    st_2._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_3, [
         ]))
    st_3._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
MD_Usage_Type._Automaton = _BuildAutomaton_87()




MD_Keywords_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'keyword'), CharacterString_PropertyType, scope=MD_Keywords_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 175, 5)))

MD_Keywords_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'type'), MD_KeywordTypeCode_PropertyType, scope=MD_Keywords_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 176, 5)))

MD_Keywords_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'thesaurusName'), CI_Citation_PropertyType, scope=MD_Keywords_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 177, 5)))

def _BuildAutomaton_88 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_88
    del _BuildAutomaton_88
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 176, 5))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 177, 5))
    counters.add(cc_1)
    states = []
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(MD_Keywords_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'keyword')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 175, 5))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(MD_Keywords_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'type')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 176, 5))
    st_1 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_1, False))
    symbol = pyxb.binding.content.ElementUse(MD_Keywords_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'thesaurusName')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 177, 5))
    st_2 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    transitions = []
    transitions.append(fac.Transition(st_0, [
         ]))
    transitions.append(fac.Transition(st_1, [
         ]))
    transitions.append(fac.Transition(st_2, [
         ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_1, True) ]))
    st_2._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
MD_Keywords_Type._Automaton = _BuildAutomaton_88()




MD_AggregateInformation_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'aggregateDataSetName'), CI_Citation_PropertyType, scope=MD_AggregateInformation_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 218, 5)))

MD_AggregateInformation_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'aggregateDataSetIdentifier'), MD_Identifier_PropertyType, scope=MD_AggregateInformation_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 219, 5)))

MD_AggregateInformation_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'associationType'), DS_AssociationTypeCode_PropertyType, scope=MD_AggregateInformation_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 220, 5)))

MD_AggregateInformation_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'initiativeType'), DS_InitiativeTypeCode_PropertyType, scope=MD_AggregateInformation_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 221, 5)))

def _BuildAutomaton_89 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_89
    del _BuildAutomaton_89
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 218, 5))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 219, 5))
    counters.add(cc_1)
    cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 221, 5))
    counters.add(cc_2)
    states = []
    final_update = None
    symbol = pyxb.binding.content.ElementUse(MD_AggregateInformation_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'aggregateDataSetName')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 218, 5))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(MD_AggregateInformation_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'aggregateDataSetIdentifier')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 219, 5))
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(MD_AggregateInformation_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'associationType')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 220, 5))
    st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_2, False))
    symbol = pyxb.binding.content.ElementUse(MD_AggregateInformation_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'initiativeType')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 221, 5))
    st_3 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_3)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_1, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_1, False) ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_3, [
         ]))
    st_2._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_2, True) ]))
    st_3._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
MD_AggregateInformation_Type._Automaton = _BuildAutomaton_89()




MD_MaintenanceInformation_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'maintenanceAndUpdateFrequency'), MD_MaintenanceFrequencyCode_PropertyType, scope=MD_MaintenanceInformation_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/maintenance.xsd', 22, 5)))

MD_MaintenanceInformation_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'dateOfNextUpdate'), Date_PropertyType, scope=MD_MaintenanceInformation_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/maintenance.xsd', 23, 5)))

MD_MaintenanceInformation_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'userDefinedMaintenanceFrequency'), TM_PeriodDuration_PropertyType, scope=MD_MaintenanceInformation_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/maintenance.xsd', 24, 5)))

MD_MaintenanceInformation_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'updateScope'), MD_ScopeCode_PropertyType, scope=MD_MaintenanceInformation_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/maintenance.xsd', 25, 5)))

MD_MaintenanceInformation_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'updateScopeDescription'), MD_ScopeDescription_PropertyType, scope=MD_MaintenanceInformation_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/maintenance.xsd', 26, 5)))

MD_MaintenanceInformation_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'maintenanceNote'), CharacterString_PropertyType, scope=MD_MaintenanceInformation_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/maintenance.xsd', 27, 5)))

MD_MaintenanceInformation_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'contact'), CI_ResponsibleParty_PropertyType, scope=MD_MaintenanceInformation_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/maintenance.xsd', 28, 5)))

def _BuildAutomaton_90 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_90
    del _BuildAutomaton_90
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/maintenance.xsd', 23, 5))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/maintenance.xsd', 24, 5))
    counters.add(cc_1)
    cc_2 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/maintenance.xsd', 25, 5))
    counters.add(cc_2)
    cc_3 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/maintenance.xsd', 26, 5))
    counters.add(cc_3)
    cc_4 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/maintenance.xsd', 27, 5))
    counters.add(cc_4)
    cc_5 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/maintenance.xsd', 28, 5))
    counters.add(cc_5)
    states = []
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(MD_MaintenanceInformation_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'maintenanceAndUpdateFrequency')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/maintenance.xsd', 22, 5))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(MD_MaintenanceInformation_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'dateOfNextUpdate')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/maintenance.xsd', 23, 5))
    st_1 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_1, False))
    symbol = pyxb.binding.content.ElementUse(MD_MaintenanceInformation_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'userDefinedMaintenanceFrequency')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/maintenance.xsd', 24, 5))
    st_2 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_2, False))
    symbol = pyxb.binding.content.ElementUse(MD_MaintenanceInformation_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'updateScope')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/maintenance.xsd', 25, 5))
    st_3 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_3)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_3, False))
    symbol = pyxb.binding.content.ElementUse(MD_MaintenanceInformation_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'updateScopeDescription')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/maintenance.xsd', 26, 5))
    st_4 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_4)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_4, False))
    symbol = pyxb.binding.content.ElementUse(MD_MaintenanceInformation_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'maintenanceNote')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/maintenance.xsd', 27, 5))
    st_5 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_5)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_5, False))
    symbol = pyxb.binding.content.ElementUse(MD_MaintenanceInformation_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'contact')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/maintenance.xsd', 28, 5))
    st_6 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_6)
    transitions = []
    transitions.append(fac.Transition(st_1, [
         ]))
    transitions.append(fac.Transition(st_2, [
         ]))
    transitions.append(fac.Transition(st_3, [
         ]))
    transitions.append(fac.Transition(st_4, [
         ]))
    transitions.append(fac.Transition(st_5, [
         ]))
    transitions.append(fac.Transition(st_6, [
         ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_1, True) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_1, False) ]))
    st_2._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_2, True) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_2, False) ]))
    st_3._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_3, True) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_3, False) ]))
    st_4._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_4, True) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_4, False) ]))
    st_5._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_5, True) ]))
    st_6._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
MD_MaintenanceInformation_Type._Automaton = _BuildAutomaton_90()




AbstractDS_Aggregate_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'composedOf'), DS_DataSet_PropertyType, scope=AbstractDS_Aggregate_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataApplication.xsd', 21, 5)))

AbstractDS_Aggregate_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'seriesMetadata'), MD_Metadata_PropertyType, scope=AbstractDS_Aggregate_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataApplication.xsd', 22, 5)))

AbstractDS_Aggregate_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'subset'), DS_Aggregate_PropertyType, scope=AbstractDS_Aggregate_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataApplication.xsd', 23, 5)))

AbstractDS_Aggregate_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'superset'), DS_Aggregate_PropertyType, scope=AbstractDS_Aggregate_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataApplication.xsd', 24, 5)))

def _BuildAutomaton_91 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_91
    del _BuildAutomaton_91
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataApplication.xsd', 23, 5))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataApplication.xsd', 24, 5))
    counters.add(cc_1)
    states = []
    final_update = None
    symbol = pyxb.binding.content.ElementUse(AbstractDS_Aggregate_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'composedOf')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataApplication.xsd', 21, 5))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(AbstractDS_Aggregate_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'seriesMetadata')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataApplication.xsd', 22, 5))
    st_1 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(AbstractDS_Aggregate_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'subset')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataApplication.xsd', 23, 5))
    st_2 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_1, False))
    symbol = pyxb.binding.content.ElementUse(AbstractDS_Aggregate_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'superset')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataApplication.xsd', 24, 5))
    st_3 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_3)
    transitions = []
    transitions.append(fac.Transition(st_0, [
         ]))
    transitions.append(fac.Transition(st_1, [
         ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_1, [
         ]))
    transitions.append(fac.Transition(st_2, [
         ]))
    transitions.append(fac.Transition(st_3, [
         ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_2._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_1, True) ]))
    st_3._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
AbstractDS_Aggregate_Type._Automaton = _BuildAutomaton_91()




DS_DataSet_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'has'), MD_Metadata_PropertyType, scope=DS_DataSet_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataApplication.xsd', 47, 5)))

DS_DataSet_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'partOf'), DS_Aggregate_PropertyType, scope=DS_DataSet_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataApplication.xsd', 48, 5)))

def _BuildAutomaton_92 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_92
    del _BuildAutomaton_92
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataApplication.xsd', 48, 5))
    counters.add(cc_0)
    states = []
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(DS_DataSet_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'has')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataApplication.xsd', 47, 5))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(DS_DataSet_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'partOf')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataApplication.xsd', 48, 5))
    st_1 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    transitions = []
    transitions.append(fac.Transition(st_0, [
         ]))
    transitions.append(fac.Transition(st_1, [
         ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_1._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
DS_DataSet_Type._Automaton = _BuildAutomaton_92()




MD_Metadata_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'fileIdentifier'), CharacterString_PropertyType, scope=MD_Metadata_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataEntity.xsd', 28, 5)))

MD_Metadata_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'language'), CharacterString_PropertyType, scope=MD_Metadata_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataEntity.xsd', 29, 5)))

MD_Metadata_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'characterSet'), MD_CharacterSetCode_PropertyType, scope=MD_Metadata_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataEntity.xsd', 30, 5)))

MD_Metadata_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'parentIdentifier'), CharacterString_PropertyType, scope=MD_Metadata_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataEntity.xsd', 31, 5)))

MD_Metadata_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'hierarchyLevel'), MD_ScopeCode_PropertyType, scope=MD_Metadata_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataEntity.xsd', 32, 5)))

MD_Metadata_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'hierarchyLevelName'), CharacterString_PropertyType, scope=MD_Metadata_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataEntity.xsd', 33, 5)))

MD_Metadata_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'contact'), CI_ResponsibleParty_PropertyType, scope=MD_Metadata_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataEntity.xsd', 34, 5)))

MD_Metadata_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'dateStamp'), Date_PropertyType, scope=MD_Metadata_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataEntity.xsd', 35, 5)))

MD_Metadata_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'metadataStandardName'), CharacterString_PropertyType, scope=MD_Metadata_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataEntity.xsd', 36, 5)))

MD_Metadata_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'metadataStandardVersion'), CharacterString_PropertyType, scope=MD_Metadata_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataEntity.xsd', 37, 5)))

MD_Metadata_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'dataSetURI'), CharacterString_PropertyType, scope=MD_Metadata_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataEntity.xsd', 38, 5)))

MD_Metadata_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'locale'), PT_Locale_PropertyType, scope=MD_Metadata_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataEntity.xsd', 39, 5)))

MD_Metadata_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'spatialRepresentationInfo'), MD_SpatialRepresentation_PropertyType, scope=MD_Metadata_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataEntity.xsd', 40, 5)))

MD_Metadata_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'referenceSystemInfo'), MD_ReferenceSystem_PropertyType, scope=MD_Metadata_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataEntity.xsd', 41, 5)))

MD_Metadata_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'metadataExtensionInfo'), MD_MetadataExtensionInformation_PropertyType, scope=MD_Metadata_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataEntity.xsd', 42, 5)))

MD_Metadata_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'identificationInfo'), MD_Identification_PropertyType, scope=MD_Metadata_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataEntity.xsd', 43, 5)))

MD_Metadata_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'contentInfo'), MD_ContentInformation_PropertyType, scope=MD_Metadata_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataEntity.xsd', 44, 5)))

MD_Metadata_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'distributionInfo'), MD_Distribution_PropertyType, scope=MD_Metadata_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataEntity.xsd', 45, 5)))

MD_Metadata_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'dataQualityInfo'), DQ_DataQuality_PropertyType, scope=MD_Metadata_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataEntity.xsd', 46, 5)))

MD_Metadata_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'portrayalCatalogueInfo'), MD_PortrayalCatalogueReference_PropertyType, scope=MD_Metadata_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataEntity.xsd', 47, 5)))

MD_Metadata_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'metadataConstraints'), MD_Constraints_PropertyType, scope=MD_Metadata_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataEntity.xsd', 48, 5)))

MD_Metadata_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'applicationSchemaInfo'), MD_ApplicationSchemaInformation_PropertyType, scope=MD_Metadata_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataEntity.xsd', 49, 5)))

MD_Metadata_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'metadataMaintenance'), MD_MaintenanceInformation_PropertyType, scope=MD_Metadata_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataEntity.xsd', 50, 5)))

MD_Metadata_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'series'), DS_Aggregate_PropertyType, scope=MD_Metadata_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataEntity.xsd', 51, 5)))

MD_Metadata_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'describes'), DS_DataSet_PropertyType, scope=MD_Metadata_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataEntity.xsd', 52, 5)))

MD_Metadata_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'propertyType'), ObjectReference_PropertyType, scope=MD_Metadata_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataEntity.xsd', 53, 5)))

MD_Metadata_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'featureType'), ObjectReference_PropertyType, scope=MD_Metadata_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataEntity.xsd', 54, 5)))

MD_Metadata_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'featureAttribute'), ObjectReference_PropertyType, scope=MD_Metadata_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataEntity.xsd', 55, 5)))

def _BuildAutomaton_93 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_93
    del _BuildAutomaton_93
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataEntity.xsd', 28, 5))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataEntity.xsd', 29, 5))
    counters.add(cc_1)
    cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataEntity.xsd', 30, 5))
    counters.add(cc_2)
    cc_3 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataEntity.xsd', 31, 5))
    counters.add(cc_3)
    cc_4 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataEntity.xsd', 32, 5))
    counters.add(cc_4)
    cc_5 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataEntity.xsd', 33, 5))
    counters.add(cc_5)
    cc_6 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataEntity.xsd', 36, 5))
    counters.add(cc_6)
    cc_7 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataEntity.xsd', 37, 5))
    counters.add(cc_7)
    cc_8 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataEntity.xsd', 38, 5))
    counters.add(cc_8)
    cc_9 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataEntity.xsd', 39, 5))
    counters.add(cc_9)
    cc_10 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataEntity.xsd', 40, 5))
    counters.add(cc_10)
    cc_11 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataEntity.xsd', 41, 5))
    counters.add(cc_11)
    cc_12 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataEntity.xsd', 42, 5))
    counters.add(cc_12)
    cc_13 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataEntity.xsd', 44, 5))
    counters.add(cc_13)
    cc_14 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataEntity.xsd', 45, 5))
    counters.add(cc_14)
    cc_15 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataEntity.xsd', 46, 5))
    counters.add(cc_15)
    cc_16 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataEntity.xsd', 47, 5))
    counters.add(cc_16)
    cc_17 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataEntity.xsd', 48, 5))
    counters.add(cc_17)
    cc_18 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataEntity.xsd', 49, 5))
    counters.add(cc_18)
    cc_19 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataEntity.xsd', 50, 5))
    counters.add(cc_19)
    cc_20 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataEntity.xsd', 51, 5))
    counters.add(cc_20)
    cc_21 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataEntity.xsd', 52, 5))
    counters.add(cc_21)
    cc_22 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataEntity.xsd', 53, 5))
    counters.add(cc_22)
    cc_23 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataEntity.xsd', 54, 5))
    counters.add(cc_23)
    cc_24 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataEntity.xsd', 55, 5))
    counters.add(cc_24)
    states = []
    final_update = None
    symbol = pyxb.binding.content.ElementUse(MD_Metadata_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'fileIdentifier')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataEntity.xsd', 28, 5))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(MD_Metadata_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'language')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataEntity.xsd', 29, 5))
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(MD_Metadata_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'characterSet')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataEntity.xsd', 30, 5))
    st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(MD_Metadata_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'parentIdentifier')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataEntity.xsd', 31, 5))
    st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_3)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(MD_Metadata_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'hierarchyLevel')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataEntity.xsd', 32, 5))
    st_4 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_4)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(MD_Metadata_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'hierarchyLevelName')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataEntity.xsd', 33, 5))
    st_5 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_5)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(MD_Metadata_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'contact')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataEntity.xsd', 34, 5))
    st_6 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_6)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(MD_Metadata_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'dateStamp')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataEntity.xsd', 35, 5))
    st_7 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_7)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(MD_Metadata_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'metadataStandardName')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataEntity.xsd', 36, 5))
    st_8 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_8)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(MD_Metadata_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'metadataStandardVersion')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataEntity.xsd', 37, 5))
    st_9 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_9)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(MD_Metadata_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'dataSetURI')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataEntity.xsd', 38, 5))
    st_10 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_10)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(MD_Metadata_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'locale')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataEntity.xsd', 39, 5))
    st_11 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_11)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(MD_Metadata_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'spatialRepresentationInfo')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataEntity.xsd', 40, 5))
    st_12 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_12)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(MD_Metadata_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'referenceSystemInfo')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataEntity.xsd', 41, 5))
    st_13 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_13)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(MD_Metadata_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'metadataExtensionInfo')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataEntity.xsd', 42, 5))
    st_14 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_14)
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(MD_Metadata_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'identificationInfo')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataEntity.xsd', 43, 5))
    st_15 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_15)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_13, False))
    symbol = pyxb.binding.content.ElementUse(MD_Metadata_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'contentInfo')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataEntity.xsd', 44, 5))
    st_16 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_16)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_14, False))
    symbol = pyxb.binding.content.ElementUse(MD_Metadata_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'distributionInfo')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataEntity.xsd', 45, 5))
    st_17 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_17)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_15, False))
    symbol = pyxb.binding.content.ElementUse(MD_Metadata_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'dataQualityInfo')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataEntity.xsd', 46, 5))
    st_18 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_18)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_16, False))
    symbol = pyxb.binding.content.ElementUse(MD_Metadata_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'portrayalCatalogueInfo')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataEntity.xsd', 47, 5))
    st_19 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_19)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_17, False))
    symbol = pyxb.binding.content.ElementUse(MD_Metadata_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'metadataConstraints')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataEntity.xsd', 48, 5))
    st_20 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_20)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_18, False))
    symbol = pyxb.binding.content.ElementUse(MD_Metadata_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'applicationSchemaInfo')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataEntity.xsd', 49, 5))
    st_21 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_21)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_19, False))
    symbol = pyxb.binding.content.ElementUse(MD_Metadata_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'metadataMaintenance')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataEntity.xsd', 50, 5))
    st_22 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_22)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_20, False))
    symbol = pyxb.binding.content.ElementUse(MD_Metadata_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'series')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataEntity.xsd', 51, 5))
    st_23 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_23)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_21, False))
    symbol = pyxb.binding.content.ElementUse(MD_Metadata_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'describes')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataEntity.xsd', 52, 5))
    st_24 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_24)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_22, False))
    symbol = pyxb.binding.content.ElementUse(MD_Metadata_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'propertyType')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataEntity.xsd', 53, 5))
    st_25 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_25)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_23, False))
    symbol = pyxb.binding.content.ElementUse(MD_Metadata_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'featureType')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataEntity.xsd', 54, 5))
    st_26 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_26)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_24, False))
    symbol = pyxb.binding.content.ElementUse(MD_Metadata_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'featureAttribute')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataEntity.xsd', 55, 5))
    st_27 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_27)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_1, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_1, False) ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_2, True) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_2, False) ]))
    st_2._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_3, True) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_3, False) ]))
    st_3._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_4, True) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_4, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_4, False) ]))
    st_4._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_5, True) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_5, False) ]))
    st_5._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_6, [
         ]))
    transitions.append(fac.Transition(st_7, [
         ]))
    st_6._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_8, [
         ]))
    transitions.append(fac.Transition(st_9, [
         ]))
    transitions.append(fac.Transition(st_10, [
         ]))
    transitions.append(fac.Transition(st_11, [
         ]))
    transitions.append(fac.Transition(st_12, [
         ]))
    transitions.append(fac.Transition(st_13, [
         ]))
    transitions.append(fac.Transition(st_14, [
         ]))
    transitions.append(fac.Transition(st_15, [
         ]))
    st_7._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_8, [
        fac.UpdateInstruction(cc_6, True) ]))
    transitions.append(fac.Transition(st_9, [
        fac.UpdateInstruction(cc_6, False) ]))
    transitions.append(fac.Transition(st_10, [
        fac.UpdateInstruction(cc_6, False) ]))
    transitions.append(fac.Transition(st_11, [
        fac.UpdateInstruction(cc_6, False) ]))
    transitions.append(fac.Transition(st_12, [
        fac.UpdateInstruction(cc_6, False) ]))
    transitions.append(fac.Transition(st_13, [
        fac.UpdateInstruction(cc_6, False) ]))
    transitions.append(fac.Transition(st_14, [
        fac.UpdateInstruction(cc_6, False) ]))
    transitions.append(fac.Transition(st_15, [
        fac.UpdateInstruction(cc_6, False) ]))
    st_8._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_9, [
        fac.UpdateInstruction(cc_7, True) ]))
    transitions.append(fac.Transition(st_10, [
        fac.UpdateInstruction(cc_7, False) ]))
    transitions.append(fac.Transition(st_11, [
        fac.UpdateInstruction(cc_7, False) ]))
    transitions.append(fac.Transition(st_12, [
        fac.UpdateInstruction(cc_7, False) ]))
    transitions.append(fac.Transition(st_13, [
        fac.UpdateInstruction(cc_7, False) ]))
    transitions.append(fac.Transition(st_14, [
        fac.UpdateInstruction(cc_7, False) ]))
    transitions.append(fac.Transition(st_15, [
        fac.UpdateInstruction(cc_7, False) ]))
    st_9._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_10, [
        fac.UpdateInstruction(cc_8, True) ]))
    transitions.append(fac.Transition(st_11, [
        fac.UpdateInstruction(cc_8, False) ]))
    transitions.append(fac.Transition(st_12, [
        fac.UpdateInstruction(cc_8, False) ]))
    transitions.append(fac.Transition(st_13, [
        fac.UpdateInstruction(cc_8, False) ]))
    transitions.append(fac.Transition(st_14, [
        fac.UpdateInstruction(cc_8, False) ]))
    transitions.append(fac.Transition(st_15, [
        fac.UpdateInstruction(cc_8, False) ]))
    st_10._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_11, [
        fac.UpdateInstruction(cc_9, True) ]))
    transitions.append(fac.Transition(st_12, [
        fac.UpdateInstruction(cc_9, False) ]))
    transitions.append(fac.Transition(st_13, [
        fac.UpdateInstruction(cc_9, False) ]))
    transitions.append(fac.Transition(st_14, [
        fac.UpdateInstruction(cc_9, False) ]))
    transitions.append(fac.Transition(st_15, [
        fac.UpdateInstruction(cc_9, False) ]))
    st_11._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_12, [
        fac.UpdateInstruction(cc_10, True) ]))
    transitions.append(fac.Transition(st_13, [
        fac.UpdateInstruction(cc_10, False) ]))
    transitions.append(fac.Transition(st_14, [
        fac.UpdateInstruction(cc_10, False) ]))
    transitions.append(fac.Transition(st_15, [
        fac.UpdateInstruction(cc_10, False) ]))
    st_12._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_13, [
        fac.UpdateInstruction(cc_11, True) ]))
    transitions.append(fac.Transition(st_14, [
        fac.UpdateInstruction(cc_11, False) ]))
    transitions.append(fac.Transition(st_15, [
        fac.UpdateInstruction(cc_11, False) ]))
    st_13._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_14, [
        fac.UpdateInstruction(cc_12, True) ]))
    transitions.append(fac.Transition(st_15, [
        fac.UpdateInstruction(cc_12, False) ]))
    st_14._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_15, [
         ]))
    transitions.append(fac.Transition(st_16, [
         ]))
    transitions.append(fac.Transition(st_17, [
         ]))
    transitions.append(fac.Transition(st_18, [
         ]))
    transitions.append(fac.Transition(st_19, [
         ]))
    transitions.append(fac.Transition(st_20, [
         ]))
    transitions.append(fac.Transition(st_21, [
         ]))
    transitions.append(fac.Transition(st_22, [
         ]))
    transitions.append(fac.Transition(st_23, [
         ]))
    transitions.append(fac.Transition(st_24, [
         ]))
    transitions.append(fac.Transition(st_25, [
         ]))
    transitions.append(fac.Transition(st_26, [
         ]))
    transitions.append(fac.Transition(st_27, [
         ]))
    st_15._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_16, [
        fac.UpdateInstruction(cc_13, True) ]))
    transitions.append(fac.Transition(st_17, [
        fac.UpdateInstruction(cc_13, False) ]))
    transitions.append(fac.Transition(st_18, [
        fac.UpdateInstruction(cc_13, False) ]))
    transitions.append(fac.Transition(st_19, [
        fac.UpdateInstruction(cc_13, False) ]))
    transitions.append(fac.Transition(st_20, [
        fac.UpdateInstruction(cc_13, False) ]))
    transitions.append(fac.Transition(st_21, [
        fac.UpdateInstruction(cc_13, False) ]))
    transitions.append(fac.Transition(st_22, [
        fac.UpdateInstruction(cc_13, False) ]))
    transitions.append(fac.Transition(st_23, [
        fac.UpdateInstruction(cc_13, False) ]))
    transitions.append(fac.Transition(st_24, [
        fac.UpdateInstruction(cc_13, False) ]))
    transitions.append(fac.Transition(st_25, [
        fac.UpdateInstruction(cc_13, False) ]))
    transitions.append(fac.Transition(st_26, [
        fac.UpdateInstruction(cc_13, False) ]))
    transitions.append(fac.Transition(st_27, [
        fac.UpdateInstruction(cc_13, False) ]))
    st_16._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_17, [
        fac.UpdateInstruction(cc_14, True) ]))
    transitions.append(fac.Transition(st_18, [
        fac.UpdateInstruction(cc_14, False) ]))
    transitions.append(fac.Transition(st_19, [
        fac.UpdateInstruction(cc_14, False) ]))
    transitions.append(fac.Transition(st_20, [
        fac.UpdateInstruction(cc_14, False) ]))
    transitions.append(fac.Transition(st_21, [
        fac.UpdateInstruction(cc_14, False) ]))
    transitions.append(fac.Transition(st_22, [
        fac.UpdateInstruction(cc_14, False) ]))
    transitions.append(fac.Transition(st_23, [
        fac.UpdateInstruction(cc_14, False) ]))
    transitions.append(fac.Transition(st_24, [
        fac.UpdateInstruction(cc_14, False) ]))
    transitions.append(fac.Transition(st_25, [
        fac.UpdateInstruction(cc_14, False) ]))
    transitions.append(fac.Transition(st_26, [
        fac.UpdateInstruction(cc_14, False) ]))
    transitions.append(fac.Transition(st_27, [
        fac.UpdateInstruction(cc_14, False) ]))
    st_17._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_18, [
        fac.UpdateInstruction(cc_15, True) ]))
    transitions.append(fac.Transition(st_19, [
        fac.UpdateInstruction(cc_15, False) ]))
    transitions.append(fac.Transition(st_20, [
        fac.UpdateInstruction(cc_15, False) ]))
    transitions.append(fac.Transition(st_21, [
        fac.UpdateInstruction(cc_15, False) ]))
    transitions.append(fac.Transition(st_22, [
        fac.UpdateInstruction(cc_15, False) ]))
    transitions.append(fac.Transition(st_23, [
        fac.UpdateInstruction(cc_15, False) ]))
    transitions.append(fac.Transition(st_24, [
        fac.UpdateInstruction(cc_15, False) ]))
    transitions.append(fac.Transition(st_25, [
        fac.UpdateInstruction(cc_15, False) ]))
    transitions.append(fac.Transition(st_26, [
        fac.UpdateInstruction(cc_15, False) ]))
    transitions.append(fac.Transition(st_27, [
        fac.UpdateInstruction(cc_15, False) ]))
    st_18._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_19, [
        fac.UpdateInstruction(cc_16, True) ]))
    transitions.append(fac.Transition(st_20, [
        fac.UpdateInstruction(cc_16, False) ]))
    transitions.append(fac.Transition(st_21, [
        fac.UpdateInstruction(cc_16, False) ]))
    transitions.append(fac.Transition(st_22, [
        fac.UpdateInstruction(cc_16, False) ]))
    transitions.append(fac.Transition(st_23, [
        fac.UpdateInstruction(cc_16, False) ]))
    transitions.append(fac.Transition(st_24, [
        fac.UpdateInstruction(cc_16, False) ]))
    transitions.append(fac.Transition(st_25, [
        fac.UpdateInstruction(cc_16, False) ]))
    transitions.append(fac.Transition(st_26, [
        fac.UpdateInstruction(cc_16, False) ]))
    transitions.append(fac.Transition(st_27, [
        fac.UpdateInstruction(cc_16, False) ]))
    st_19._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_20, [
        fac.UpdateInstruction(cc_17, True) ]))
    transitions.append(fac.Transition(st_21, [
        fac.UpdateInstruction(cc_17, False) ]))
    transitions.append(fac.Transition(st_22, [
        fac.UpdateInstruction(cc_17, False) ]))
    transitions.append(fac.Transition(st_23, [
        fac.UpdateInstruction(cc_17, False) ]))
    transitions.append(fac.Transition(st_24, [
        fac.UpdateInstruction(cc_17, False) ]))
    transitions.append(fac.Transition(st_25, [
        fac.UpdateInstruction(cc_17, False) ]))
    transitions.append(fac.Transition(st_26, [
        fac.UpdateInstruction(cc_17, False) ]))
    transitions.append(fac.Transition(st_27, [
        fac.UpdateInstruction(cc_17, False) ]))
    st_20._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_21, [
        fac.UpdateInstruction(cc_18, True) ]))
    transitions.append(fac.Transition(st_22, [
        fac.UpdateInstruction(cc_18, False) ]))
    transitions.append(fac.Transition(st_23, [
        fac.UpdateInstruction(cc_18, False) ]))
    transitions.append(fac.Transition(st_24, [
        fac.UpdateInstruction(cc_18, False) ]))
    transitions.append(fac.Transition(st_25, [
        fac.UpdateInstruction(cc_18, False) ]))
    transitions.append(fac.Transition(st_26, [
        fac.UpdateInstruction(cc_18, False) ]))
    transitions.append(fac.Transition(st_27, [
        fac.UpdateInstruction(cc_18, False) ]))
    st_21._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_22, [
        fac.UpdateInstruction(cc_19, True) ]))
    transitions.append(fac.Transition(st_23, [
        fac.UpdateInstruction(cc_19, False) ]))
    transitions.append(fac.Transition(st_24, [
        fac.UpdateInstruction(cc_19, False) ]))
    transitions.append(fac.Transition(st_25, [
        fac.UpdateInstruction(cc_19, False) ]))
    transitions.append(fac.Transition(st_26, [
        fac.UpdateInstruction(cc_19, False) ]))
    transitions.append(fac.Transition(st_27, [
        fac.UpdateInstruction(cc_19, False) ]))
    st_22._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_23, [
        fac.UpdateInstruction(cc_20, True) ]))
    transitions.append(fac.Transition(st_24, [
        fac.UpdateInstruction(cc_20, False) ]))
    transitions.append(fac.Transition(st_25, [
        fac.UpdateInstruction(cc_20, False) ]))
    transitions.append(fac.Transition(st_26, [
        fac.UpdateInstruction(cc_20, False) ]))
    transitions.append(fac.Transition(st_27, [
        fac.UpdateInstruction(cc_20, False) ]))
    st_23._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_24, [
        fac.UpdateInstruction(cc_21, True) ]))
    transitions.append(fac.Transition(st_25, [
        fac.UpdateInstruction(cc_21, False) ]))
    transitions.append(fac.Transition(st_26, [
        fac.UpdateInstruction(cc_21, False) ]))
    transitions.append(fac.Transition(st_27, [
        fac.UpdateInstruction(cc_21, False) ]))
    st_24._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_25, [
        fac.UpdateInstruction(cc_22, True) ]))
    transitions.append(fac.Transition(st_26, [
        fac.UpdateInstruction(cc_22, False) ]))
    transitions.append(fac.Transition(st_27, [
        fac.UpdateInstruction(cc_22, False) ]))
    st_25._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_26, [
        fac.UpdateInstruction(cc_23, True) ]))
    transitions.append(fac.Transition(st_27, [
        fac.UpdateInstruction(cc_23, False) ]))
    st_26._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_27, [
        fac.UpdateInstruction(cc_24, True) ]))
    st_27._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
MD_Metadata_Type._Automaton = _BuildAutomaton_93()




MD_ExtendedElementInformation_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'name'), CharacterString_PropertyType, scope=MD_ExtendedElementInformation_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataExtension.xsd', 21, 5)))

MD_ExtendedElementInformation_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'shortName'), CharacterString_PropertyType, scope=MD_ExtendedElementInformation_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataExtension.xsd', 22, 5)))

MD_ExtendedElementInformation_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'domainCode'), Integer_PropertyType, scope=MD_ExtendedElementInformation_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataExtension.xsd', 23, 5)))

MD_ExtendedElementInformation_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'definition'), CharacterString_PropertyType, scope=MD_ExtendedElementInformation_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataExtension.xsd', 24, 5)))

MD_ExtendedElementInformation_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'obligation'), MD_ObligationCode_PropertyType, scope=MD_ExtendedElementInformation_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataExtension.xsd', 25, 5)))

MD_ExtendedElementInformation_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'condition'), CharacterString_PropertyType, scope=MD_ExtendedElementInformation_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataExtension.xsd', 26, 5)))

MD_ExtendedElementInformation_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'dataType'), MD_DatatypeCode_PropertyType, scope=MD_ExtendedElementInformation_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataExtension.xsd', 27, 5)))

MD_ExtendedElementInformation_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'maximumOccurrence'), CharacterString_PropertyType, scope=MD_ExtendedElementInformation_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataExtension.xsd', 28, 5)))

MD_ExtendedElementInformation_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'domainValue'), CharacterString_PropertyType, scope=MD_ExtendedElementInformation_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataExtension.xsd', 29, 5)))

MD_ExtendedElementInformation_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'parentEntity'), CharacterString_PropertyType, scope=MD_ExtendedElementInformation_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataExtension.xsd', 30, 5)))

MD_ExtendedElementInformation_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'rule'), CharacterString_PropertyType, scope=MD_ExtendedElementInformation_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataExtension.xsd', 31, 5)))

MD_ExtendedElementInformation_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'rationale'), CharacterString_PropertyType, scope=MD_ExtendedElementInformation_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataExtension.xsd', 32, 5)))

MD_ExtendedElementInformation_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'source'), CI_ResponsibleParty_PropertyType, scope=MD_ExtendedElementInformation_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataExtension.xsd', 33, 5)))

def _BuildAutomaton_94 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_94
    del _BuildAutomaton_94
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataExtension.xsd', 22, 5))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataExtension.xsd', 23, 5))
    counters.add(cc_1)
    cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataExtension.xsd', 25, 5))
    counters.add(cc_2)
    cc_3 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataExtension.xsd', 26, 5))
    counters.add(cc_3)
    cc_4 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataExtension.xsd', 28, 5))
    counters.add(cc_4)
    cc_5 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataExtension.xsd', 29, 5))
    counters.add(cc_5)
    cc_6 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataExtension.xsd', 32, 5))
    counters.add(cc_6)
    states = []
    final_update = None
    symbol = pyxb.binding.content.ElementUse(MD_ExtendedElementInformation_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'name')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataExtension.xsd', 21, 5))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(MD_ExtendedElementInformation_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'shortName')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataExtension.xsd', 22, 5))
    st_1 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(MD_ExtendedElementInformation_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'domainCode')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataExtension.xsd', 23, 5))
    st_2 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(MD_ExtendedElementInformation_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'definition')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataExtension.xsd', 24, 5))
    st_3 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_3)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(MD_ExtendedElementInformation_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'obligation')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataExtension.xsd', 25, 5))
    st_4 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_4)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(MD_ExtendedElementInformation_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'condition')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataExtension.xsd', 26, 5))
    st_5 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_5)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(MD_ExtendedElementInformation_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'dataType')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataExtension.xsd', 27, 5))
    st_6 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_6)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(MD_ExtendedElementInformation_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'maximumOccurrence')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataExtension.xsd', 28, 5))
    st_7 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_7)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(MD_ExtendedElementInformation_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'domainValue')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataExtension.xsd', 29, 5))
    st_8 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_8)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(MD_ExtendedElementInformation_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'parentEntity')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataExtension.xsd', 30, 5))
    st_9 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_9)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(MD_ExtendedElementInformation_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'rule')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataExtension.xsd', 31, 5))
    st_10 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_10)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(MD_ExtendedElementInformation_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'rationale')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataExtension.xsd', 32, 5))
    st_11 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_11)
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(MD_ExtendedElementInformation_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'source')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataExtension.xsd', 33, 5))
    st_12 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_12)
    transitions = []
    transitions.append(fac.Transition(st_1, [
         ]))
    transitions.append(fac.Transition(st_2, [
         ]))
    transitions.append(fac.Transition(st_3, [
         ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_1, True) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_1, False) ]))
    st_2._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
         ]))
    transitions.append(fac.Transition(st_5, [
         ]))
    transitions.append(fac.Transition(st_6, [
         ]))
    st_3._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_2, True) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_2, False) ]))
    st_4._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_3, True) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_3, False) ]))
    st_5._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_7, [
         ]))
    transitions.append(fac.Transition(st_8, [
         ]))
    transitions.append(fac.Transition(st_9, [
         ]))
    st_6._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_4, True) ]))
    transitions.append(fac.Transition(st_8, [
        fac.UpdateInstruction(cc_4, False) ]))
    transitions.append(fac.Transition(st_9, [
        fac.UpdateInstruction(cc_4, False) ]))
    st_7._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_8, [
        fac.UpdateInstruction(cc_5, True) ]))
    transitions.append(fac.Transition(st_9, [
        fac.UpdateInstruction(cc_5, False) ]))
    st_8._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_9, [
         ]))
    transitions.append(fac.Transition(st_10, [
         ]))
    st_9._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_11, [
         ]))
    transitions.append(fac.Transition(st_12, [
         ]))
    st_10._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_11, [
        fac.UpdateInstruction(cc_6, True) ]))
    transitions.append(fac.Transition(st_12, [
        fac.UpdateInstruction(cc_6, False) ]))
    st_11._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_12, [
         ]))
    st_12._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
MD_ExtendedElementInformation_Type._Automaton = _BuildAutomaton_94()




MD_MetadataExtensionInformation_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'extensionOnLineResource'), CI_OnlineResource_PropertyType, scope=MD_MetadataExtensionInformation_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataExtension.xsd', 56, 5)))

MD_MetadataExtensionInformation_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'extendedElementInformation'), MD_ExtendedElementInformation_PropertyType, scope=MD_MetadataExtensionInformation_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataExtension.xsd', 57, 5)))

def _BuildAutomaton_95 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_95
    del _BuildAutomaton_95
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataExtension.xsd', 56, 5))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataExtension.xsd', 57, 5))
    counters.add(cc_1)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(MD_MetadataExtensionInformation_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'extensionOnLineResource')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataExtension.xsd', 56, 5))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_1, False))
    symbol = pyxb.binding.content.ElementUse(MD_MetadataExtensionInformation_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'extendedElementInformation')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataExtension.xsd', 57, 5))
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_1, True) ]))
    st_1._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
MD_MetadataExtensionInformation_Type._Automaton = _BuildAutomaton_95()




MD_PortrayalCatalogueReference_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'portrayalCatalogueCitation'), CI_Citation_PropertyType, scope=MD_PortrayalCatalogueReference_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/portrayalCatalogue.xsd', 21, 5)))

def _BuildAutomaton_96 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_96
    del _BuildAutomaton_96
    import pyxb.utils.fac as fac

    counters = set()
    states = []
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(MD_PortrayalCatalogueReference_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'portrayalCatalogueCitation')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/portrayalCatalogue.xsd', 21, 5))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
         ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
MD_PortrayalCatalogueReference_Type._Automaton = _BuildAutomaton_96()




MD_ReferenceSystem_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'referenceSystemIdentifier'), RS_Identifier_PropertyType, scope=MD_ReferenceSystem_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/referenceSystem.xsd', 40, 5)))

def _BuildAutomaton_97 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_97
    del _BuildAutomaton_97
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/referenceSystem.xsd', 40, 5))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(MD_ReferenceSystem_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'referenceSystemIdentifier')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/referenceSystem.xsd', 40, 5))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
MD_ReferenceSystem_Type._Automaton = _BuildAutomaton_97()




MD_Identifier_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'authority'), CI_Citation_PropertyType, scope=MD_Identifier_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/referenceSystem.xsd', 60, 5)))

MD_Identifier_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'code'), CharacterString_PropertyType, scope=MD_Identifier_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/referenceSystem.xsd', 61, 5)))

def _BuildAutomaton_98 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_98
    del _BuildAutomaton_98
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/referenceSystem.xsd', 60, 5))
    counters.add(cc_0)
    states = []
    final_update = None
    symbol = pyxb.binding.content.ElementUse(MD_Identifier_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'authority')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/referenceSystem.xsd', 60, 5))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(MD_Identifier_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'code')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/referenceSystem.xsd', 61, 5))
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    st_1._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
MD_Identifier_Type._Automaton = _BuildAutomaton_98()




AbstractRS_ReferenceSystem_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'name'), RS_Identifier_PropertyType, scope=AbstractRS_ReferenceSystem_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/referenceSystem.xsd', 84, 5)))

AbstractRS_ReferenceSystem_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'domainOfValidity'), EX_Extent_PropertyType, scope=AbstractRS_ReferenceSystem_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/referenceSystem.xsd', 85, 5)))

def _BuildAutomaton_99 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_99
    del _BuildAutomaton_99
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/referenceSystem.xsd', 85, 5))
    counters.add(cc_0)
    states = []
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(AbstractRS_ReferenceSystem_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'name')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/referenceSystem.xsd', 84, 5))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(AbstractRS_ReferenceSystem_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'domainOfValidity')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/referenceSystem.xsd', 85, 5))
    st_1 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    transitions = []
    transitions.append(fac.Transition(st_1, [
         ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_1._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
AbstractRS_ReferenceSystem_Type._Automaton = _BuildAutomaton_99()




MD_Dimension_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'dimensionName'), MD_DimensionNameTypeCode_PropertyType, scope=MD_Dimension_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/spatialRepresentation.xsd', 114, 5)))

MD_Dimension_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'dimensionSize'), Integer_PropertyType, scope=MD_Dimension_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/spatialRepresentation.xsd', 115, 5)))

MD_Dimension_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'resolution'), Measure_PropertyType, scope=MD_Dimension_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/spatialRepresentation.xsd', 116, 5)))

def _BuildAutomaton_100 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_100
    del _BuildAutomaton_100
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/spatialRepresentation.xsd', 116, 5))
    counters.add(cc_0)
    states = []
    final_update = None
    symbol = pyxb.binding.content.ElementUse(MD_Dimension_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'dimensionName')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/spatialRepresentation.xsd', 114, 5))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(MD_Dimension_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'dimensionSize')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/spatialRepresentation.xsd', 115, 5))
    st_1 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(MD_Dimension_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'resolution')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/spatialRepresentation.xsd', 116, 5))
    st_2 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    transitions = []
    transitions.append(fac.Transition(st_1, [
         ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_2, [
         ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_2._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
MD_Dimension_Type._Automaton = _BuildAutomaton_100()




MD_GeometricObjects_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'geometricObjectType'), MD_GeometricObjectTypeCode_PropertyType, scope=MD_GeometricObjects_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/spatialRepresentation.xsd', 162, 5)))

MD_GeometricObjects_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'geometricObjectCount'), Integer_PropertyType, scope=MD_GeometricObjects_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/spatialRepresentation.xsd', 163, 5)))

def _BuildAutomaton_101 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_101
    del _BuildAutomaton_101
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/spatialRepresentation.xsd', 163, 5))
    counters.add(cc_0)
    states = []
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(MD_GeometricObjects_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'geometricObjectType')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/spatialRepresentation.xsd', 162, 5))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(MD_GeometricObjects_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'geometricObjectCount')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/spatialRepresentation.xsd', 163, 5))
    st_1 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    transitions = []
    transitions.append(fac.Transition(st_1, [
         ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_1._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
MD_GeometricObjects_Type._Automaton = _BuildAutomaton_101()




ParameterValueType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'value'), MeasureType, scope=ParameterValueType, documentation='gml:value is a numeric value of an operation parameter, with its associated unit of measure.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 324, 1)))

ParameterValueType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'stringValue'), pyxb.binding.datatypes.string, scope=ParameterValueType, documentation='gml:stringValue is a character string value of an operation parameter. A string value does not have an associated unit of measure.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 329, 1)))

ParameterValueType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'integerValue'), pyxb.binding.datatypes.positiveInteger, scope=ParameterValueType, documentation='gml:integerValue is a positive integer value of an operation parameter, usually used for a count. An integer value does not have an associated unit of measure.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 334, 1)))

ParameterValueType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'booleanValue'), pyxb.binding.datatypes.boolean, scope=ParameterValueType, documentation='gml:booleanValue is a boolean value of an operation parameter. A Boolean value does not have an associated unit of measure.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 339, 1)))

ParameterValueType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'valueList'), MeasureListType, scope=ParameterValueType, documentation='gml:valueList is an ordered sequence of two or more numeric values of an operation parameter list, where each value has the same associated unit of measure. An element of this type contains a space-separated sequence of double values.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 344, 1)))

ParameterValueType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'integerValueList'), integerList, scope=ParameterValueType, documentation='gml:integerValueList is an ordered sequence of two or more integer values of an operation parameter list, usually used for counts. These integer values do not have an associated unit of measure. An element of this type contains a space-separated sequence of integer values.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 349, 1)))

ParameterValueType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'valueFile'), pyxb.binding.datatypes.anyURI, scope=ParameterValueType, documentation='gml:valueFile is a reference to a file or a part of a file containing one or more parameter values, each numeric value with its associated unit of measure. When referencing a part of a file, that file shall contain multiple identified parts, such as an XML encoded document. Furthermore, the referenced file or part of a file may reference another part of the same or different files, as allowed in XML documents.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 354, 1)))

ParameterValueType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'operationParameter'), OperationParameterPropertyType, scope=ParameterValueType, documentation='gml:operationParameter is an association role to the operation parameter of which this is a value.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 359, 1)))

ParameterValueType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'dmsAngleValue'), DMSAngleType, scope=ParameterValueType, documentation='', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 152, 1)))

def _BuildAutomaton_102 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_102
    del _BuildAutomaton_102
    import pyxb.utils.fac as fac

    counters = set()
    states = []
    final_update = None
    symbol = pyxb.binding.content.ElementUse(ParameterValueType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'value')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 310, 6))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(ParameterValueType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'dmsAngleValue')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 311, 6))
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(ParameterValueType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'stringValue')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 312, 6))
    st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(ParameterValueType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'integerValue')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 313, 6))
    st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_3)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(ParameterValueType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'booleanValue')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 314, 6))
    st_4 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_4)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(ParameterValueType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'valueList')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 315, 6))
    st_5 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_5)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(ParameterValueType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'integerValueList')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 316, 6))
    st_6 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_6)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(ParameterValueType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'valueFile')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 317, 6))
    st_7 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_7)
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(ParameterValueType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'operationParameter')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 319, 5))
    st_8 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_8)
    transitions = []
    transitions.append(fac.Transition(st_8, [
         ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_8, [
         ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_8, [
         ]))
    st_2._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_8, [
         ]))
    st_3._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_8, [
         ]))
    st_4._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_8, [
         ]))
    st_5._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_8, [
         ]))
    st_6._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_8, [
         ]))
    st_7._set_transitionSet(transitions)
    transitions = []
    st_8._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
ParameterValueType._Automaton = _BuildAutomaton_102()




ParameterValueGroupType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'parameterValue'), AbstractGeneralParameterValuePropertyType, scope=ParameterValueGroupType, documentation='gml:parameterValue is a composition association to a parameter value or group of parameter values used by a coordinate operation.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 243, 1)))

ParameterValueGroupType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'group'), OperationParameterGroupPropertyType, scope=ParameterValueGroupType, documentation='gml:group is an association role to the operation parameter group for which this element provides parameter values.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 380, 1)))

def _BuildAutomaton_103 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_103
    del _BuildAutomaton_103
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=2, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 374, 5))
    counters.add(cc_0)
    states = []
    final_update = None
    symbol = pyxb.binding.content.ElementUse(ParameterValueGroupType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'parameterValue')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 374, 5))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(ParameterValueGroupType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'group')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 375, 5))
    st_1 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    st_1._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
ParameterValueGroupType._Automaton = _BuildAutomaton_103()




BagType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'member'), AssociationRoleType, scope=BagType, documentation='', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 643, 1)))

BagType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'members'), ArrayAssociationType, scope=BagType, documentation='', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 657, 1)))

def _BuildAutomaton_104 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_104
    del _BuildAutomaton_104
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 39, 3))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 40, 3))
    counters.add(cc_1)
    cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 41, 3))
    counters.add(cc_2)
    cc_3 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 42, 3))
    counters.add(cc_3)
    cc_4 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 43, 3))
    counters.add(cc_4)
    cc_5 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 689, 5))
    counters.add(cc_5)
    cc_6 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 690, 5))
    counters.add(cc_6)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(BagType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'metaDataProperty')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 39, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_1, False))
    symbol = pyxb.binding.content.ElementUse(BagType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'description')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 40, 3))
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_2, False))
    symbol = pyxb.binding.content.ElementUse(BagType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'descriptionReference')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 41, 3))
    st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_3, False))
    symbol = pyxb.binding.content.ElementUse(BagType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'identifier')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 42, 3))
    st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_3)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_4, False))
    symbol = pyxb.binding.content.ElementUse(BagType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'name')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 43, 3))
    st_4 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_4)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_5, False))
    symbol = pyxb.binding.content.ElementUse(BagType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'member')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 689, 5))
    st_5 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_5)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_6, False))
    symbol = pyxb.binding.content.ElementUse(BagType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'members')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 690, 5))
    st_6 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_6)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_1, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_1, False) ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_2, True) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_2, False) ]))
    st_2._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_3, True) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_3, False) ]))
    st_3._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_4, True) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_4, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_4, False) ]))
    st_4._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_5, True) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_5, False) ]))
    st_5._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_6, True) ]))
    st_6._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
BagType._Automaton = _BuildAutomaton_104()




ArrayType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'members'), ArrayAssociationType, scope=ArrayType, documentation='', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 657, 1)))

def _BuildAutomaton_105 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_105
    del _BuildAutomaton_105
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 39, 3))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 40, 3))
    counters.add(cc_1)
    cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 41, 3))
    counters.add(cc_2)
    cc_3 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 42, 3))
    counters.add(cc_3)
    cc_4 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 43, 3))
    counters.add(cc_4)
    cc_5 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 707, 5))
    counters.add(cc_5)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(ArrayType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'metaDataProperty')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 39, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_1, False))
    symbol = pyxb.binding.content.ElementUse(ArrayType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'description')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 40, 3))
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_2, False))
    symbol = pyxb.binding.content.ElementUse(ArrayType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'descriptionReference')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 41, 3))
    st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_3, False))
    symbol = pyxb.binding.content.ElementUse(ArrayType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'identifier')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 42, 3))
    st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_3)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_4, False))
    symbol = pyxb.binding.content.ElementUse(ArrayType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'name')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 43, 3))
    st_4 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_4)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_5, False))
    symbol = pyxb.binding.content.ElementUse(ArrayType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'members')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 707, 5))
    st_5 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_5)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_1, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_1, False) ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_2, True) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_2, False) ]))
    st_2._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_3, True) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_3, False) ]))
    st_3._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_4, True) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_4, False) ]))
    st_4._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_5, True) ]))
    st_5._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
ArrayType._Automaton = _BuildAutomaton_105()




def _BuildAutomaton_106 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_106
    del _BuildAutomaton_106
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 746, 5))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.WildcardUse(pyxb.binding.content.Wildcard(process_contents=pyxb.binding.content.Wildcard.PC_lax, namespace_constraint=pyxb.binding.content.Wildcard.NC_any), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 746, 5))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
GenericMetaDataType._Automaton = _BuildAutomaton_106()




def _BuildAutomaton_107 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_107
    del _BuildAutomaton_107
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 35, 5))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 36, 5))
    counters.add(cc_1)
    cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 37, 5))
    counters.add(cc_2)
    cc_3 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 39, 5))
    counters.add(cc_3)
    states = []
    final_update = None
    symbol = pyxb.binding.content.ElementUse(DefinitionBaseType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'metaDataProperty')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 35, 5))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(DefinitionBaseType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'description')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 36, 5))
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(DefinitionBaseType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'descriptionReference')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 37, 5))
    st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(DefinitionBaseType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'identifier')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 38, 5))
    st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_3)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_3, False))
    symbol = pyxb.binding.content.ElementUse(DefinitionBaseType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'name')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 39, 5))
    st_4 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_4)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_1, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_1, False) ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_2, True) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_2, False) ]))
    st_2._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
         ]))
    st_3._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_3, True) ]))
    st_4._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
DefinitionBaseType._Automaton = _BuildAutomaton_107()




AbstractTimeSliceType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'dataSource'), StringOrRefType, scope=AbstractTimeSliceType, documentation='Evidence is represented by a simple gml:dataSource or gml:dataSourceReference property that indicates the source of the temporal data. The remote link attributes of the gml:dataSource element have been deprecated along with its current type.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dynamicFeature.xsd', 17, 1)))

AbstractTimeSliceType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'validTime'), TimePrimitivePropertyType, scope=AbstractTimeSliceType, documentation='gml:validTime is a convenience property element.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporal.xsd', 52, 1)))

def _BuildAutomaton_108 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_108
    del _BuildAutomaton_108
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 39, 3))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 40, 3))
    counters.add(cc_1)
    cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 41, 3))
    counters.add(cc_2)
    cc_3 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 42, 3))
    counters.add(cc_3)
    cc_4 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 43, 3))
    counters.add(cc_4)
    cc_5 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dynamicFeature.xsd', 92, 5))
    counters.add(cc_5)
    states = []
    final_update = None
    symbol = pyxb.binding.content.ElementUse(AbstractTimeSliceType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'metaDataProperty')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 39, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(AbstractTimeSliceType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'description')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 40, 3))
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(AbstractTimeSliceType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'descriptionReference')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 41, 3))
    st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(AbstractTimeSliceType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'identifier')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 42, 3))
    st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_3)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(AbstractTimeSliceType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'name')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 43, 3))
    st_4 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_4)
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(AbstractTimeSliceType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'validTime')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dynamicFeature.xsd', 91, 5))
    st_5 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_5)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_5, False))
    symbol = pyxb.binding.content.ElementUse(AbstractTimeSliceType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'dataSource')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dynamicFeature.xsd', 92, 5))
    st_6 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_6)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_1, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_1, False) ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_2, True) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_2, False) ]))
    st_2._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_3, True) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_3, False) ]))
    st_3._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_4, True) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_4, False) ]))
    st_4._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_6, [
         ]))
    st_5._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_5, True) ]))
    st_6._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
AbstractTimeSliceType._Automaton = _BuildAutomaton_108()




AbstractFeatureType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'location'), LocationPropertyType, scope=AbstractFeatureType, documentation='', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 761, 1)))

AbstractFeatureType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'boundedBy'), BoundingShapeType, nillable=pyxb.binding.datatypes.boolean(1), scope=AbstractFeatureType, documentation='This property describes the minimum bounding box or rectangle that encloses the entire feature.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/feature.xsd', 45, 1)))

def _BuildAutomaton_109 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_109
    del _BuildAutomaton_109
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 39, 3))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 40, 3))
    counters.add(cc_1)
    cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 41, 3))
    counters.add(cc_2)
    cc_3 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 42, 3))
    counters.add(cc_3)
    cc_4 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 43, 3))
    counters.add(cc_4)
    cc_5 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/feature.xsd', 26, 5))
    counters.add(cc_5)
    cc_6 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/feature.xsd', 27, 5))
    counters.add(cc_6)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(AbstractFeatureType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'metaDataProperty')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 39, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_1, False))
    symbol = pyxb.binding.content.ElementUse(AbstractFeatureType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'description')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 40, 3))
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_2, False))
    symbol = pyxb.binding.content.ElementUse(AbstractFeatureType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'descriptionReference')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 41, 3))
    st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_3, False))
    symbol = pyxb.binding.content.ElementUse(AbstractFeatureType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'identifier')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 42, 3))
    st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_3)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_4, False))
    symbol = pyxb.binding.content.ElementUse(AbstractFeatureType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'name')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 43, 3))
    st_4 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_4)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_5, False))
    symbol = pyxb.binding.content.ElementUse(AbstractFeatureType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'boundedBy')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/feature.xsd', 26, 5))
    st_5 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_5)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_6, False))
    symbol = pyxb.binding.content.ElementUse(AbstractFeatureType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'location')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/feature.xsd', 27, 5))
    st_6 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_6)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_1, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_1, False) ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_2, True) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_2, False) ]))
    st_2._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_3, True) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_3, False) ]))
    st_3._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_4, True) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_4, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_4, False) ]))
    st_4._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_5, True) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_5, False) ]))
    st_5._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_6, True) ]))
    st_6._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
AbstractFeatureType._Automaton = _BuildAutomaton_109()




def _BuildAutomaton_110 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_110
    del _BuildAutomaton_110
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 39, 3))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 40, 3))
    counters.add(cc_1)
    cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 41, 3))
    counters.add(cc_2)
    cc_3 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 42, 3))
    counters.add(cc_3)
    cc_4 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 43, 3))
    counters.add(cc_4)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(AbstractGeometryType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'metaDataProperty')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 39, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_1, False))
    symbol = pyxb.binding.content.ElementUse(AbstractGeometryType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'description')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 40, 3))
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_2, False))
    symbol = pyxb.binding.content.ElementUse(AbstractGeometryType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'descriptionReference')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 41, 3))
    st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_3, False))
    symbol = pyxb.binding.content.ElementUse(AbstractGeometryType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'identifier')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 42, 3))
    st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_3)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_4, False))
    symbol = pyxb.binding.content.ElementUse(AbstractGeometryType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'name')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 43, 3))
    st_4 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_4)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_1, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_1, False) ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_2, True) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_2, False) ]))
    st_2._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_3, True) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_3, False) ]))
    st_3._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_4, True) ]))
    st_4._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
AbstractGeometryType._Automaton = _BuildAutomaton_110()




EnvelopeType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'coordinates'), CoordinatesType, scope=EnvelopeType, documentation='', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 751, 1)))

EnvelopeType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'pos'), DirectPositionType, scope=EnvelopeType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic0d1d.xsd', 87, 1)))

EnvelopeType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'lowerCorner'), DirectPositionType, scope=EnvelopeType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic0d1d.xsd', 136, 4)))

EnvelopeType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'upperCorner'), DirectPositionType, scope=EnvelopeType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic0d1d.xsd', 137, 4)))

def _BuildAutomaton_111 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_111
    del _BuildAutomaton_111
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=2, max=2, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic0d1d.xsd', 139, 3))
    counters.add(cc_0)
    states = []
    final_update = None
    symbol = pyxb.binding.content.ElementUse(EnvelopeType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'lowerCorner')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic0d1d.xsd', 136, 4))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(EnvelopeType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'upperCorner')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic0d1d.xsd', 137, 4))
    st_1 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(EnvelopeType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'pos')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic0d1d.xsd', 139, 3))
    st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(EnvelopeType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'coordinates')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic0d1d.xsd', 144, 3))
    st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_3)
    transitions = []
    transitions.append(fac.Transition(st_1, [
         ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_2._set_transitionSet(transitions)
    transitions = []
    st_3._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
EnvelopeType._Automaton = _BuildAutomaton_111()




LineStringSegmentType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'coordinates'), CoordinatesType, scope=LineStringSegmentType, documentation='', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 751, 1)))

LineStringSegmentType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'pointRep'), PointPropertyType, scope=LineStringSegmentType, documentation='', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 756, 1)))

LineStringSegmentType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'pos'), DirectPositionType, scope=LineStringSegmentType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic0d1d.xsd', 87, 1)))

LineStringSegmentType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'posList'), DirectPositionListType, scope=LineStringSegmentType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic0d1d.xsd', 102, 1)))

LineStringSegmentType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'pointProperty'), PointPropertyType, scope=LineStringSegmentType, documentation='This property element either references a point via the XLink-attributes or contains the point element. pointProperty is the predefined property which may be used by GML Application Schemas whenever a GML feature has a property with a value that is substitutable for Point.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic0d1d.xsd', 204, 1)))

def _BuildAutomaton_112 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_112
    del _BuildAutomaton_112
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=2, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 101, 6))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(LineStringSegmentType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'pos')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 102, 7))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(LineStringSegmentType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'pointProperty')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 103, 7))
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(LineStringSegmentType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'pointRep')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 104, 7))
    st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(LineStringSegmentType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'posList')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 106, 6))
    st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_3)
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(LineStringSegmentType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'coordinates')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 107, 6))
    st_4 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_4)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_2._set_transitionSet(transitions)
    transitions = []
    st_3._set_transitionSet(transitions)
    transitions = []
    st_4._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
LineStringSegmentType._Automaton = _BuildAutomaton_112()




ArcStringType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'coordinates'), CoordinatesType, scope=ArcStringType, documentation='', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 751, 1)))

ArcStringType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'pointRep'), PointPropertyType, scope=ArcStringType, documentation='', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 756, 1)))

ArcStringType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'pos'), DirectPositionType, scope=ArcStringType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic0d1d.xsd', 87, 1)))

ArcStringType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'posList'), DirectPositionListType, scope=ArcStringType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic0d1d.xsd', 102, 1)))

ArcStringType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'pointProperty'), PointPropertyType, scope=ArcStringType, documentation='This property element either references a point via the XLink-attributes or contains the point element. pointProperty is the predefined property which may be used by GML Application Schemas whenever a GML feature has a property with a value that is substitutable for Point.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic0d1d.xsd', 204, 1)))

def _BuildAutomaton_113 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_113
    del _BuildAutomaton_113
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=3, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 125, 6))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(ArcStringType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'pos')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 126, 7))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(ArcStringType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'pointProperty')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 127, 7))
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(ArcStringType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'pointRep')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 128, 7))
    st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(ArcStringType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'posList')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 130, 6))
    st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_3)
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(ArcStringType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'coordinates')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 131, 6))
    st_4 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_4)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_2._set_transitionSet(transitions)
    transitions = []
    st_3._set_transitionSet(transitions)
    transitions = []
    st_4._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
ArcStringType._Automaton = _BuildAutomaton_113()




ArcStringByBulgeType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'coordinates'), CoordinatesType, scope=ArcStringByBulgeType, documentation='', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 751, 1)))

ArcStringByBulgeType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'pointRep'), PointPropertyType, scope=ArcStringByBulgeType, documentation='', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 756, 1)))

ArcStringByBulgeType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'pos'), DirectPositionType, scope=ArcStringByBulgeType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic0d1d.xsd', 87, 1)))

ArcStringByBulgeType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'posList'), DirectPositionListType, scope=ArcStringByBulgeType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic0d1d.xsd', 102, 1)))

ArcStringByBulgeType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'pointProperty'), PointPropertyType, scope=ArcStringByBulgeType, documentation='This property element either references a point via the XLink-attributes or contains the point element. pointProperty is the predefined property which may be used by GML Application Schemas whenever a GML feature has a property with a value that is substitutable for Point.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic0d1d.xsd', 204, 1)))

ArcStringByBulgeType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'bulge'), pyxb.binding.datatypes.double, scope=ArcStringByBulgeType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 191, 5)))

ArcStringByBulgeType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'normal'), VectorType, scope=ArcStringByBulgeType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 192, 5)))

def _BuildAutomaton_114 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_114
    del _BuildAutomaton_114
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=2, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 183, 6))
    counters.add(cc_0)
    states = []
    final_update = None
    symbol = pyxb.binding.content.ElementUse(ArcStringByBulgeType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'pos')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 184, 7))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(ArcStringByBulgeType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'pointProperty')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 185, 7))
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(ArcStringByBulgeType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'pointRep')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 186, 7))
    st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(ArcStringByBulgeType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'posList')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 188, 6))
    st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_3)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(ArcStringByBulgeType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'coordinates')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 189, 6))
    st_4 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_4)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(ArcStringByBulgeType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'bulge')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 191, 5))
    st_5 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_5)
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(ArcStringByBulgeType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'normal')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 192, 5))
    st_6 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_6)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_2._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_5, [
         ]))
    st_3._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_5, [
         ]))
    st_4._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_5, [
         ]))
    transitions.append(fac.Transition(st_6, [
         ]))
    st_5._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_6, [
         ]))
    st_6._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
ArcStringByBulgeType._Automaton = _BuildAutomaton_114()




ArcByCenterPointType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'coordinates'), CoordinatesType, scope=ArcByCenterPointType, documentation='', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 751, 1)))

ArcByCenterPointType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'pointRep'), PointPropertyType, scope=ArcByCenterPointType, documentation='', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 756, 1)))

ArcByCenterPointType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'pos'), DirectPositionType, scope=ArcByCenterPointType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic0d1d.xsd', 87, 1)))

ArcByCenterPointType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'posList'), DirectPositionListType, scope=ArcByCenterPointType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic0d1d.xsd', 102, 1)))

ArcByCenterPointType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'pointProperty'), PointPropertyType, scope=ArcByCenterPointType, documentation='This property element either references a point via the XLink-attributes or contains the point element. pointProperty is the predefined property which may be used by GML Application Schemas whenever a GML feature has a property with a value that is substitutable for Point.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic0d1d.xsd', 204, 1)))

ArcByCenterPointType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'radius'), LengthType, scope=ArcByCenterPointType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 246, 5)))

ArcByCenterPointType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'startAngle'), AngleType, scope=ArcByCenterPointType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 247, 5)))

ArcByCenterPointType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'endAngle'), AngleType, scope=ArcByCenterPointType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 248, 5)))

def _BuildAutomaton_115 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_115
    del _BuildAutomaton_115
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 247, 5))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 248, 5))
    counters.add(cc_1)
    states = []
    final_update = None
    symbol = pyxb.binding.content.ElementUse(ArcByCenterPointType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'pos')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 239, 7))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(ArcByCenterPointType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'pointProperty')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 240, 7))
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(ArcByCenterPointType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'pointRep')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 241, 7))
    st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(ArcByCenterPointType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'posList')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 243, 6))
    st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_3)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(ArcByCenterPointType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'coordinates')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 244, 6))
    st_4 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_4)
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(ArcByCenterPointType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'radius')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 246, 5))
    st_5 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_5)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(ArcByCenterPointType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'startAngle')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 247, 5))
    st_6 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_6)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_1, False))
    symbol = pyxb.binding.content.ElementUse(ArcByCenterPointType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'endAngle')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 248, 5))
    st_7 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_7)
    transitions = []
    transitions.append(fac.Transition(st_5, [
         ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_5, [
         ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_5, [
         ]))
    st_2._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_5, [
         ]))
    st_3._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_5, [
         ]))
    st_4._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_6, [
         ]))
    transitions.append(fac.Transition(st_7, [
         ]))
    st_5._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_6._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_1, True) ]))
    st_7._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
ArcByCenterPointType._Automaton = _BuildAutomaton_115()




CubicSplineType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'coordinates'), CoordinatesType, scope=CubicSplineType, documentation='', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 751, 1)))

CubicSplineType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'pointRep'), PointPropertyType, scope=CubicSplineType, documentation='', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 756, 1)))

CubicSplineType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'pos'), DirectPositionType, scope=CubicSplineType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic0d1d.xsd', 87, 1)))

CubicSplineType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'posList'), DirectPositionListType, scope=CubicSplineType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic0d1d.xsd', 102, 1)))

CubicSplineType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'pointProperty'), PointPropertyType, scope=CubicSplineType, documentation='This property element either references a point via the XLink-attributes or contains the point element. pointProperty is the predefined property which may be used by GML Application Schemas whenever a GML feature has a property with a value that is substitutable for Point.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic0d1d.xsd', 204, 1)))

CubicSplineType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'vectorAtStart'), VectorType, scope=CubicSplineType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 302, 5)))

CubicSplineType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'vectorAtEnd'), VectorType, scope=CubicSplineType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 303, 5)))

def _BuildAutomaton_116 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_116
    del _BuildAutomaton_116
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=2, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 294, 6))
    counters.add(cc_0)
    states = []
    final_update = None
    symbol = pyxb.binding.content.ElementUse(CubicSplineType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'pos')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 295, 7))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(CubicSplineType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'pointProperty')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 296, 7))
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(CubicSplineType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'pointRep')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 297, 7))
    st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(CubicSplineType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'posList')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 299, 6))
    st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_3)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(CubicSplineType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'coordinates')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 300, 6))
    st_4 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_4)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(CubicSplineType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'vectorAtStart')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 302, 5))
    st_5 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_5)
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(CubicSplineType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'vectorAtEnd')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 303, 5))
    st_6 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_6)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_2._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_5, [
         ]))
    st_3._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_5, [
         ]))
    st_4._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_6, [
         ]))
    st_5._set_transitionSet(transitions)
    transitions = []
    st_6._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
CubicSplineType._Automaton = _BuildAutomaton_116()




BSplineType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'coordinates'), CoordinatesType, scope=BSplineType, documentation='', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 751, 1)))

BSplineType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'pointRep'), PointPropertyType, scope=BSplineType, documentation='', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 756, 1)))

BSplineType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'pos'), DirectPositionType, scope=BSplineType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic0d1d.xsd', 87, 1)))

BSplineType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'posList'), DirectPositionListType, scope=BSplineType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic0d1d.xsd', 102, 1)))

BSplineType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'pointProperty'), PointPropertyType, scope=BSplineType, documentation='This property element either references a point via the XLink-attributes or contains the point element. pointProperty is the predefined property which may be used by GML Application Schemas whenever a GML feature has a property with a value that is substitutable for Point.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic0d1d.xsd', 204, 1)))

BSplineType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'degree'), pyxb.binding.datatypes.nonNegativeInteger, scope=BSplineType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 332, 5)))

BSplineType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'knot'), KnotPropertyType, scope=BSplineType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 333, 5)))

def _BuildAutomaton_117 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_117
    del _BuildAutomaton_117
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 324, 6))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=2, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 333, 5))
    counters.add(cc_1)
    states = []
    final_update = None
    symbol = pyxb.binding.content.ElementUse(BSplineType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'pos')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 325, 7))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(BSplineType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'pointProperty')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 326, 7))
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(BSplineType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'pointRep')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 327, 7))
    st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(BSplineType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'posList')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 329, 6))
    st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_3)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(BSplineType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'coordinates')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 330, 6))
    st_4 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_4)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(BSplineType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'degree')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 332, 5))
    st_5 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_5)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_1, False))
    symbol = pyxb.binding.content.ElementUse(BSplineType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'knot')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 333, 5))
    st_6 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_6)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_2._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_5, [
         ]))
    st_3._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_5, [
         ]))
    st_4._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_6, [
         ]))
    st_5._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_1, True) ]))
    st_6._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
BSplineType._Automaton = _BuildAutomaton_117()




OffsetCurveType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'offsetBase'), CurvePropertyType, scope=OffsetCurveType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 420, 5)))

OffsetCurveType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'distance'), LengthType, scope=OffsetCurveType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 421, 5)))

OffsetCurveType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'refDirection'), VectorType, scope=OffsetCurveType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 422, 5)))

def _BuildAutomaton_118 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_118
    del _BuildAutomaton_118
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 422, 5))
    counters.add(cc_0)
    states = []
    final_update = None
    symbol = pyxb.binding.content.ElementUse(OffsetCurveType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'offsetBase')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 420, 5))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(OffsetCurveType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'distance')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 421, 5))
    st_1 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(OffsetCurveType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'refDirection')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 422, 5))
    st_2 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    transitions = []
    transitions.append(fac.Transition(st_1, [
         ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_2, [
         ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_2._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
OffsetCurveType._Automaton = _BuildAutomaton_118()




ClothoidType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'refLocation'), CTD_ANON_2, scope=ClothoidType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 450, 5)))

ClothoidType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'scaleFactor'), pyxb.binding.datatypes.decimal, scope=ClothoidType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 457, 5)))

ClothoidType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'startParameter'), pyxb.binding.datatypes.double, scope=ClothoidType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 458, 5)))

ClothoidType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'endParameter'), pyxb.binding.datatypes.double, scope=ClothoidType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 459, 5)))

def _BuildAutomaton_119 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_119
    del _BuildAutomaton_119
    import pyxb.utils.fac as fac

    counters = set()
    states = []
    final_update = None
    symbol = pyxb.binding.content.ElementUse(ClothoidType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'refLocation')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 450, 5))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(ClothoidType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'scaleFactor')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 457, 5))
    st_1 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(ClothoidType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'startParameter')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 458, 5))
    st_2 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(ClothoidType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'endParameter')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 459, 5))
    st_3 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_3)
    transitions = []
    transitions.append(fac.Transition(st_1, [
         ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_2, [
         ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_3, [
         ]))
    st_2._set_transitionSet(transitions)
    transitions = []
    st_3._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
ClothoidType._Automaton = _BuildAutomaton_119()




GeodesicStringType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'pos'), DirectPositionType, scope=GeodesicStringType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic0d1d.xsd', 87, 1)))

GeodesicStringType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'posList'), DirectPositionListType, scope=GeodesicStringType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic0d1d.xsd', 102, 1)))

GeodesicStringType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'pointProperty'), PointPropertyType, scope=GeodesicStringType, documentation='This property element either references a point via the XLink-attributes or contains the point element. pointProperty is the predefined property which may be used by GML Application Schemas whenever a GML feature has a property with a value that is substitutable for Point.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic0d1d.xsd', 204, 1)))

def _BuildAutomaton_120 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_120
    del _BuildAutomaton_120
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=2, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 478, 5))
    counters.add(cc_0)
    states = []
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(GeodesicStringType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'posList')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 477, 5))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(GeodesicStringType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'pos')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic0d1d.xsd', 110, 3))
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(GeodesicStringType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'pointProperty')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic0d1d.xsd', 111, 3))
    st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    transitions = []
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_2._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
GeodesicStringType._Automaton = _BuildAutomaton_120()




PolygonPatchType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'exterior'), AbstractRingPropertyType, scope=PolygonPatchType, documentation='A boundary of a surface consists of a number of rings. In the normal 2D case, one of these rings is distinguished as being the exterior boundary. In a general manifold this is not always possible, in which case all boundaries shall be listed as interior boundaries, and the exterior will be empty.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic2d.xsd', 67, 1)))

PolygonPatchType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'interior'), AbstractRingPropertyType, scope=PolygonPatchType, documentation='A boundary of a surface consists of a number of rings. The "interior" rings separate the surface / surface patch from the area enclosed by the rings.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic2d.xsd', 72, 1)))

def _BuildAutomaton_121 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_121
    del _BuildAutomaton_121
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 575, 5))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 576, 5))
    counters.add(cc_1)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(PolygonPatchType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'exterior')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 575, 5))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_1, False))
    symbol = pyxb.binding.content.ElementUse(PolygonPatchType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'interior')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 576, 5))
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_1, True) ]))
    st_1._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
PolygonPatchType._Automaton = _BuildAutomaton_121()




TriangleType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'exterior'), AbstractRingPropertyType, scope=TriangleType, documentation='A boundary of a surface consists of a number of rings. In the normal 2D case, one of these rings is distinguished as being the exterior boundary. In a general manifold this is not always possible, in which case all boundaries shall be listed as interior boundaries, and the exterior will be empty.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic2d.xsd', 67, 1)))

def _BuildAutomaton_122 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_122
    del _BuildAutomaton_122
    import pyxb.utils.fac as fac

    counters = set()
    states = []
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(TriangleType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'exterior')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 592, 5))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
TriangleType._Automaton = _BuildAutomaton_122()




RectangleType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'exterior'), AbstractRingPropertyType, scope=RectangleType, documentation='A boundary of a surface consists of a number of rings. In the normal 2D case, one of these rings is distinguished as being the exterior boundary. In a general manifold this is not always possible, in which case all boundaries shall be listed as interior boundaries, and the exterior will be empty.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic2d.xsd', 67, 1)))

def _BuildAutomaton_123 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_123
    del _BuildAutomaton_123
    import pyxb.utils.fac as fac

    counters = set()
    states = []
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(RectangleType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'exterior')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 609, 5))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
RectangleType._Automaton = _BuildAutomaton_123()




def _BuildAutomaton_124 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_124
    del _BuildAutomaton_124
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 39, 3))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 40, 3))
    counters.add(cc_1)
    cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 41, 3))
    counters.add(cc_2)
    cc_3 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 42, 3))
    counters.add(cc_3)
    cc_4 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 43, 3))
    counters.add(cc_4)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(AbstractTimeObjectType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'metaDataProperty')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 39, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_1, False))
    symbol = pyxb.binding.content.ElementUse(AbstractTimeObjectType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'description')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 40, 3))
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_2, False))
    symbol = pyxb.binding.content.ElementUse(AbstractTimeObjectType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'descriptionReference')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 41, 3))
    st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_3, False))
    symbol = pyxb.binding.content.ElementUse(AbstractTimeObjectType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'identifier')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 42, 3))
    st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_3)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_4, False))
    symbol = pyxb.binding.content.ElementUse(AbstractTimeObjectType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'name')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 43, 3))
    st_4 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_4)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_1, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_1, False) ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_2, True) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_2, False) ]))
    st_2._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_3, True) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_3, False) ]))
    st_3._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_4, True) ]))
    st_4._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
AbstractTimeObjectType._Automaton = _BuildAutomaton_124()




def _BuildAutomaton_125 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_125
    del _BuildAutomaton_125
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 39, 3))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 40, 3))
    counters.add(cc_1)
    cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 41, 3))
    counters.add(cc_2)
    cc_3 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 42, 3))
    counters.add(cc_3)
    cc_4 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 43, 3))
    counters.add(cc_4)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(AbstractTopologyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'metaDataProperty')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 39, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_1, False))
    symbol = pyxb.binding.content.ElementUse(AbstractTopologyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'description')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 40, 3))
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_2, False))
    symbol = pyxb.binding.content.ElementUse(AbstractTopologyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'descriptionReference')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 41, 3))
    st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_3, False))
    symbol = pyxb.binding.content.ElementUse(AbstractTopologyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'identifier')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 42, 3))
    st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_3)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_4, False))
    symbol = pyxb.binding.content.ElementUse(AbstractTopologyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'name')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 43, 3))
    st_4 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_4)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_1, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_1, False) ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_2, True) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_2, False) ]))
    st_2._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_3, True) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_3, False) ]))
    st_3._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_4, True) ]))
    st_4._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
AbstractTopologyType._Automaton = _BuildAutomaton_125()




CompositeValueType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'valueComponent'), ValuePropertyType, scope=CompositeValueType, documentation='Property that refers to, or contains, a Value.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/valueObjects.xsd', 102, 1)))

CompositeValueType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'valueComponents'), ValueArrayPropertyType, scope=CompositeValueType, documentation='Property that contains Values.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/valueObjects.xsd', 114, 1)))

def _BuildAutomaton_126 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_126
    del _BuildAutomaton_126
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 39, 3))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 40, 3))
    counters.add(cc_1)
    cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 41, 3))
    counters.add(cc_2)
    cc_3 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 42, 3))
    counters.add(cc_3)
    cc_4 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 43, 3))
    counters.add(cc_4)
    cc_5 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/valueObjects.xsd', 134, 5))
    counters.add(cc_5)
    cc_6 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/valueObjects.xsd', 135, 5))
    counters.add(cc_6)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(CompositeValueType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'metaDataProperty')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 39, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_1, False))
    symbol = pyxb.binding.content.ElementUse(CompositeValueType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'description')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 40, 3))
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_2, False))
    symbol = pyxb.binding.content.ElementUse(CompositeValueType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'descriptionReference')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 41, 3))
    st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_3, False))
    symbol = pyxb.binding.content.ElementUse(CompositeValueType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'identifier')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 42, 3))
    st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_3)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_4, False))
    symbol = pyxb.binding.content.ElementUse(CompositeValueType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'name')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 43, 3))
    st_4 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_4)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_5, False))
    symbol = pyxb.binding.content.ElementUse(CompositeValueType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'valueComponent')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/valueObjects.xsd', 134, 5))
    st_5 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_5)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_6, False))
    symbol = pyxb.binding.content.ElementUse(CompositeValueType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'valueComponents')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/valueObjects.xsd', 135, 5))
    st_6 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_6)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_1, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_1, False) ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_2, True) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_2, False) ]))
    st_2._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_3, True) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_3, False) ]))
    st_3._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_4, True) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_4, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_4, False) ]))
    st_4._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_5, True) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_5, False) ]))
    st_5._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_6, True) ]))
    st_6._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
CompositeValueType._Automaton = _BuildAutomaton_126()




TypeName_PropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gco, 'TypeName'), TypeName_Type, scope=TypeName_PropertyType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 30, 1)))

def _BuildAutomaton_127 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_127
    del _BuildAutomaton_127
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 33, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(TypeName_PropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gco, 'TypeName')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 34, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
TypeName_PropertyType._Automaton = _BuildAutomaton_127()




MemberName_PropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gco, 'MemberName'), MemberName_Type, scope=MemberName_PropertyType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 54, 1)))

def _BuildAutomaton_128 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_128
    del _BuildAutomaton_128
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 57, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(MemberName_PropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gco, 'MemberName')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 58, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
MemberName_PropertyType._Automaton = _BuildAutomaton_128()




Multiplicity_PropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gco, 'Multiplicity'), Multiplicity_Type, scope=Multiplicity_PropertyType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 77, 1)))

def _BuildAutomaton_129 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_129
    del _BuildAutomaton_129
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 80, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(Multiplicity_PropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gco, 'Multiplicity')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 81, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
Multiplicity_PropertyType._Automaton = _BuildAutomaton_129()




MultiplicityRange_PropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gco, 'MultiplicityRange'), MultiplicityRange_Type, scope=MultiplicityRange_PropertyType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 101, 1)))

def _BuildAutomaton_130 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_130
    del _BuildAutomaton_130
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 104, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(MultiplicityRange_PropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gco, 'MultiplicityRange')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 105, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
MultiplicityRange_PropertyType._Automaton = _BuildAutomaton_130()




Measure_PropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gco, 'Measure'), MeasureType, scope=Measure_PropertyType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 113, 1)))

def _BuildAutomaton_131 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_131
    del _BuildAutomaton_131
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 116, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(Measure_PropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gco, 'Measure')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 117, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
Measure_PropertyType._Automaton = _BuildAutomaton_131()




Length_PropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gco, 'Length'), LengthType, scope=Length_PropertyType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 123, 1)))

def _BuildAutomaton_132 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_132
    del _BuildAutomaton_132
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 126, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(Length_PropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gco, 'Length')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 127, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
Length_PropertyType._Automaton = _BuildAutomaton_132()




Angle_PropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gco, 'Angle'), AngleType, scope=Angle_PropertyType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 133, 1)))

def _BuildAutomaton_133 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_133
    del _BuildAutomaton_133
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 136, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(Angle_PropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gco, 'Angle')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 137, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
Angle_PropertyType._Automaton = _BuildAutomaton_133()




Scale_PropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gco, 'Scale'), ScaleType, scope=Scale_PropertyType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 143, 1)))

def _BuildAutomaton_134 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_134
    del _BuildAutomaton_134
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 146, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(Scale_PropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gco, 'Scale')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 147, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
Scale_PropertyType._Automaton = _BuildAutomaton_134()




Distance_PropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gco, 'Distance'), LengthType, scope=Distance_PropertyType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 153, 1)))

def _BuildAutomaton_135 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_135
    del _BuildAutomaton_135
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 156, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(Distance_PropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gco, 'Distance')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 157, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
Distance_PropertyType._Automaton = _BuildAutomaton_135()




CharacterString_PropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gco, 'CharacterString'), pyxb.binding.datatypes.string, scope=CharacterString_PropertyType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 163, 1)))

def _BuildAutomaton_136 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_136
    del _BuildAutomaton_136
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 166, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(CharacterString_PropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gco, 'CharacterString')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 167, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
CharacterString_PropertyType._Automaton = _BuildAutomaton_136()




Boolean_PropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gco, 'Boolean'), pyxb.binding.datatypes.boolean, scope=Boolean_PropertyType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 173, 1)))

def _BuildAutomaton_137 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_137
    del _BuildAutomaton_137
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 176, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(Boolean_PropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gco, 'Boolean')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 177, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
Boolean_PropertyType._Automaton = _BuildAutomaton_137()




GenericName_PropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gco, 'AbstractGenericName'), CodeType, abstract=pyxb.binding.datatypes.boolean(1), scope=GenericName_PropertyType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 183, 1)))

def _BuildAutomaton_138 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_138
    del _BuildAutomaton_138
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 186, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(GenericName_PropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gco, 'AbstractGenericName')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 187, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
GenericName_PropertyType._Automaton = _BuildAutomaton_138()




LocalName_PropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gco, 'LocalName'), CodeType, scope=LocalName_PropertyType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 193, 1)))

def _BuildAutomaton_139 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_139
    del _BuildAutomaton_139
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 196, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(LocalName_PropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gco, 'LocalName')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 197, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
LocalName_PropertyType._Automaton = _BuildAutomaton_139()




ScopedName_PropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gco, 'ScopedName'), CodeType, scope=ScopedName_PropertyType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 203, 1)))

def _BuildAutomaton_140 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_140
    del _BuildAutomaton_140
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 206, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(ScopedName_PropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gco, 'ScopedName')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 207, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
ScopedName_PropertyType._Automaton = _BuildAutomaton_140()




UomAngle_PropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'UnitDefinition'), UnitDefinitionType, scope=UomAngle_PropertyType, documentation='A gml:UnitDefinition is a general definition of a unit of measure. This generic element is used only for units for which no relationship with other units or units systems is known.\nThe content model of gml:UnitDefinition adds three additional properties to gml:Definition, gml:quantityType, gml:quantityTypeReference and gml:catalogSymbol.  \nThe gml:catalogSymbol property optionally gives the short symbol used for this unit. This element is usually used when the relationship of this unit to other units or units systems is unknown.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/units.xsd', 30, 1)))

def _BuildAutomaton_141 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_141
    del _BuildAutomaton_141
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 216, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(UomAngle_PropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'UnitDefinition')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 217, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
UomAngle_PropertyType._Automaton = _BuildAutomaton_141()




UomLength_PropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'UnitDefinition'), UnitDefinitionType, scope=UomLength_PropertyType, documentation='A gml:UnitDefinition is a general definition of a unit of measure. This generic element is used only for units for which no relationship with other units or units systems is known.\nThe content model of gml:UnitDefinition adds three additional properties to gml:Definition, gml:quantityType, gml:quantityTypeReference and gml:catalogSymbol.  \nThe gml:catalogSymbol property optionally gives the short symbol used for this unit. This element is usually used when the relationship of this unit to other units or units systems is unknown.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/units.xsd', 30, 1)))

def _BuildAutomaton_142 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_142
    del _BuildAutomaton_142
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 226, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(UomLength_PropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'UnitDefinition')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 227, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
UomLength_PropertyType._Automaton = _BuildAutomaton_142()




UomScale_PropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'UnitDefinition'), UnitDefinitionType, scope=UomScale_PropertyType, documentation='A gml:UnitDefinition is a general definition of a unit of measure. This generic element is used only for units for which no relationship with other units or units systems is known.\nThe content model of gml:UnitDefinition adds three additional properties to gml:Definition, gml:quantityType, gml:quantityTypeReference and gml:catalogSymbol.  \nThe gml:catalogSymbol property optionally gives the short symbol used for this unit. This element is usually used when the relationship of this unit to other units or units systems is unknown.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/units.xsd', 30, 1)))

def _BuildAutomaton_143 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_143
    del _BuildAutomaton_143
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 236, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(UomScale_PropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'UnitDefinition')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 237, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
UomScale_PropertyType._Automaton = _BuildAutomaton_143()




UnitOfMeasure_PropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'UnitDefinition'), UnitDefinitionType, scope=UnitOfMeasure_PropertyType, documentation='A gml:UnitDefinition is a general definition of a unit of measure. This generic element is used only for units for which no relationship with other units or units systems is known.\nThe content model of gml:UnitDefinition adds three additional properties to gml:Definition, gml:quantityType, gml:quantityTypeReference and gml:catalogSymbol.  \nThe gml:catalogSymbol property optionally gives the short symbol used for this unit. This element is usually used when the relationship of this unit to other units or units systems is unknown.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/units.xsd', 30, 1)))

def _BuildAutomaton_144 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_144
    del _BuildAutomaton_144
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 246, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(UnitOfMeasure_PropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'UnitDefinition')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 247, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
UnitOfMeasure_PropertyType._Automaton = _BuildAutomaton_144()




UomArea_PropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'UnitDefinition'), UnitDefinitionType, scope=UomArea_PropertyType, documentation='A gml:UnitDefinition is a general definition of a unit of measure. This generic element is used only for units for which no relationship with other units or units systems is known.\nThe content model of gml:UnitDefinition adds three additional properties to gml:Definition, gml:quantityType, gml:quantityTypeReference and gml:catalogSymbol.  \nThe gml:catalogSymbol property optionally gives the short symbol used for this unit. This element is usually used when the relationship of this unit to other units or units systems is unknown.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/units.xsd', 30, 1)))

def _BuildAutomaton_145 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_145
    del _BuildAutomaton_145
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 256, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(UomArea_PropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'UnitDefinition')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 257, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
UomArea_PropertyType._Automaton = _BuildAutomaton_145()




UomVelocity_PropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'UnitDefinition'), UnitDefinitionType, scope=UomVelocity_PropertyType, documentation='A gml:UnitDefinition is a general definition of a unit of measure. This generic element is used only for units for which no relationship with other units or units systems is known.\nThe content model of gml:UnitDefinition adds three additional properties to gml:Definition, gml:quantityType, gml:quantityTypeReference and gml:catalogSymbol.  \nThe gml:catalogSymbol property optionally gives the short symbol used for this unit. This element is usually used when the relationship of this unit to other units or units systems is unknown.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/units.xsd', 30, 1)))

def _BuildAutomaton_146 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_146
    del _BuildAutomaton_146
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 266, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(UomVelocity_PropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'UnitDefinition')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 267, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
UomVelocity_PropertyType._Automaton = _BuildAutomaton_146()




UomTime_PropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'UnitDefinition'), UnitDefinitionType, scope=UomTime_PropertyType, documentation='A gml:UnitDefinition is a general definition of a unit of measure. This generic element is used only for units for which no relationship with other units or units systems is known.\nThe content model of gml:UnitDefinition adds three additional properties to gml:Definition, gml:quantityType, gml:quantityTypeReference and gml:catalogSymbol.  \nThe gml:catalogSymbol property optionally gives the short symbol used for this unit. This element is usually used when the relationship of this unit to other units or units systems is unknown.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/units.xsd', 30, 1)))

def _BuildAutomaton_147 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_147
    del _BuildAutomaton_147
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 276, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(UomTime_PropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'UnitDefinition')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 277, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
UomTime_PropertyType._Automaton = _BuildAutomaton_147()




UomVolume_PropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'UnitDefinition'), UnitDefinitionType, scope=UomVolume_PropertyType, documentation='A gml:UnitDefinition is a general definition of a unit of measure. This generic element is used only for units for which no relationship with other units or units systems is known.\nThe content model of gml:UnitDefinition adds three additional properties to gml:Definition, gml:quantityType, gml:quantityTypeReference and gml:catalogSymbol.  \nThe gml:catalogSymbol property optionally gives the short symbol used for this unit. This element is usually used when the relationship of this unit to other units or units systems is unknown.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/units.xsd', 30, 1)))

def _BuildAutomaton_148 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_148
    del _BuildAutomaton_148
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 286, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(UomVolume_PropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'UnitDefinition')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 287, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
UomVolume_PropertyType._Automaton = _BuildAutomaton_148()




DateTime_PropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gco, 'DateTime'), pyxb.binding.datatypes.dateTime, scope=DateTime_PropertyType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 295, 1)))

def _BuildAutomaton_149 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_149
    del _BuildAutomaton_149
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 298, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(DateTime_PropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gco, 'DateTime')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 299, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
DateTime_PropertyType._Automaton = _BuildAutomaton_149()




Date_PropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gco, 'DateTime'), pyxb.binding.datatypes.dateTime, scope=Date_PropertyType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 295, 1)))

Date_PropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gco, 'Date'), Date_Type, nillable=pyxb.binding.datatypes.boolean(1), scope=Date_PropertyType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 308, 1)))

def _BuildAutomaton_150 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_150
    del _BuildAutomaton_150
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 311, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(Date_PropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gco, 'Date')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 312, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(Date_PropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gco, 'DateTime')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 313, 3))
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_1._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
Date_PropertyType._Automaton = _BuildAutomaton_150()




Number_PropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gco, 'Decimal'), pyxb.binding.datatypes.decimal, scope=Number_PropertyType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 330, 1)))

Number_PropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gco, 'Real'), pyxb.binding.datatypes.double, scope=Number_PropertyType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 340, 1)))

Number_PropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gco, 'Integer'), pyxb.binding.datatypes.integer, scope=Number_PropertyType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 350, 1)))

def _BuildAutomaton_151 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_151
    del _BuildAutomaton_151
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 321, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(Number_PropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gco, 'Real')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 322, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(Number_PropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gco, 'Decimal')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 323, 3))
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(Number_PropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gco, 'Integer')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 324, 3))
    st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_2._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
Number_PropertyType._Automaton = _BuildAutomaton_151()




Decimal_PropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gco, 'Decimal'), pyxb.binding.datatypes.decimal, scope=Decimal_PropertyType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 330, 1)))

def _BuildAutomaton_152 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_152
    del _BuildAutomaton_152
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 333, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(Decimal_PropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gco, 'Decimal')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 334, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
Decimal_PropertyType._Automaton = _BuildAutomaton_152()




Real_PropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gco, 'Real'), pyxb.binding.datatypes.double, scope=Real_PropertyType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 340, 1)))

def _BuildAutomaton_153 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_153
    del _BuildAutomaton_153
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 343, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(Real_PropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gco, 'Real')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 344, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
Real_PropertyType._Automaton = _BuildAutomaton_153()




Integer_PropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gco, 'Integer'), pyxb.binding.datatypes.integer, scope=Integer_PropertyType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 350, 1)))

def _BuildAutomaton_154 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_154
    del _BuildAutomaton_154
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 353, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(Integer_PropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gco, 'Integer')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 354, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
Integer_PropertyType._Automaton = _BuildAutomaton_154()




UnlimitedInteger_PropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gco, 'UnlimitedInteger'), UnlimitedInteger_Type, nillable=pyxb.binding.datatypes.boolean(1), scope=UnlimitedInteger_PropertyType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 370, 1)))

def _BuildAutomaton_155 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_155
    del _BuildAutomaton_155
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 373, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(UnlimitedInteger_PropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gco, 'UnlimitedInteger')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 374, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
UnlimitedInteger_PropertyType._Automaton = _BuildAutomaton_155()




Record_PropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gco, 'Record'), pyxb.binding.datatypes.anyType, scope=Record_PropertyType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 381, 1)))

def _BuildAutomaton_156 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_156
    del _BuildAutomaton_156
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 384, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(Record_PropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gco, 'Record')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 385, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
Record_PropertyType._Automaton = _BuildAutomaton_156()




RecordType_PropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gco, 'RecordType'), RecordType_Type, scope=RecordType_PropertyType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 400, 1)))

def _BuildAutomaton_157 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_157
    del _BuildAutomaton_157
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 403, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(RecordType_PropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gco, 'RecordType')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 404, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
RecordType_PropertyType._Automaton = _BuildAutomaton_157()




Binary_PropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gco, 'Binary'), Binary_Type, scope=Binary_PropertyType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 420, 1)))

def _BuildAutomaton_158 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_158
    del _BuildAutomaton_158
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 423, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(Binary_PropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gco, 'Binary')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 424, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
Binary_PropertyType._Automaton = _BuildAutomaton_158()




MD_ApplicationSchemaInformation_PropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_ApplicationSchemaInformation'), MD_ApplicationSchemaInformation_Type, scope=MD_ApplicationSchemaInformation_PropertyType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/applicationSchema.xsd', 33, 1)))

def _BuildAutomaton_159 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_159
    del _BuildAutomaton_159
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/applicationSchema.xsd', 36, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(MD_ApplicationSchemaInformation_PropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_ApplicationSchemaInformation')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/applicationSchema.xsd', 37, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
MD_ApplicationSchemaInformation_PropertyType._Automaton = _BuildAutomaton_159()




CI_ResponsibleParty_PropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'CI_ResponsibleParty'), CI_ResponsibleParty_Type, scope=CI_ResponsibleParty_PropertyType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 31, 1)))

def _BuildAutomaton_160 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_160
    del _BuildAutomaton_160
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 34, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(CI_ResponsibleParty_PropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'CI_ResponsibleParty')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 35, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
CI_ResponsibleParty_PropertyType._Automaton = _BuildAutomaton_160()




CI_Citation_PropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'CI_Citation'), CI_Citation_Type, scope=CI_Citation_PropertyType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 66, 1)))

def _BuildAutomaton_161 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_161
    del _BuildAutomaton_161
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 69, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(CI_Citation_PropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'CI_Citation')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 70, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
CI_Citation_PropertyType._Automaton = _BuildAutomaton_161()




CI_Address_PropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'CI_Address'), CI_Address_Type, scope=CI_Address_PropertyType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 94, 1)))

def _BuildAutomaton_162 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_162
    del _BuildAutomaton_162
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 97, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(CI_Address_PropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'CI_Address')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 98, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
CI_Address_PropertyType._Automaton = _BuildAutomaton_162()




CI_OnlineResource_PropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'CI_OnlineResource'), CI_OnlineResource_Type, scope=CI_OnlineResource_PropertyType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 122, 1)))

def _BuildAutomaton_163 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_163
    del _BuildAutomaton_163
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 125, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(CI_OnlineResource_PropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'CI_OnlineResource')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 126, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
CI_OnlineResource_PropertyType._Automaton = _BuildAutomaton_163()




CI_Contact_PropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'CI_Contact'), CI_Contact_Type, scope=CI_Contact_PropertyType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 149, 1)))

def _BuildAutomaton_164 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_164
    del _BuildAutomaton_164
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 152, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(CI_Contact_PropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'CI_Contact')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 153, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
CI_Contact_PropertyType._Automaton = _BuildAutomaton_164()




CI_Telephone_PropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'CI_Telephone'), CI_Telephone_Type, scope=CI_Telephone_PropertyType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 173, 1)))

def _BuildAutomaton_165 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_165
    del _BuildAutomaton_165
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 176, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(CI_Telephone_PropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'CI_Telephone')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 177, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
CI_Telephone_PropertyType._Automaton = _BuildAutomaton_165()




CI_Date_PropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'CI_Date'), CI_Date_Type, scope=CI_Date_PropertyType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 194, 1)))

def _BuildAutomaton_166 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_166
    del _BuildAutomaton_166
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 197, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(CI_Date_PropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'CI_Date')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 198, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
CI_Date_PropertyType._Automaton = _BuildAutomaton_166()




CI_Series_PropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'CI_Series'), CI_Series_Type, scope=CI_Series_PropertyType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 216, 1)))

def _BuildAutomaton_167 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_167
    del _BuildAutomaton_167
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 219, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(CI_Series_PropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'CI_Series')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 220, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
CI_Series_PropertyType._Automaton = _BuildAutomaton_167()




URL_PropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'URL'), pyxb.binding.datatypes.anyURI, scope=URL_PropertyType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 227, 1)))

def _BuildAutomaton_168 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_168
    del _BuildAutomaton_168
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 230, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(URL_PropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'URL')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 231, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
URL_PropertyType._Automaton = _BuildAutomaton_168()




CI_RoleCode_PropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'CI_RoleCode'), CodeListValue_Type, scope=CI_RoleCode_PropertyType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 237, 1)))

def _BuildAutomaton_169 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_169
    del _BuildAutomaton_169
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 240, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(CI_RoleCode_PropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'CI_RoleCode')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 241, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
CI_RoleCode_PropertyType._Automaton = _BuildAutomaton_169()




CI_PresentationFormCode_PropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'CI_PresentationFormCode'), CodeListValue_Type, scope=CI_PresentationFormCode_PropertyType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 247, 1)))

def _BuildAutomaton_170 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_170
    del _BuildAutomaton_170
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 250, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(CI_PresentationFormCode_PropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'CI_PresentationFormCode')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 251, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
CI_PresentationFormCode_PropertyType._Automaton = _BuildAutomaton_170()




CI_OnLineFunctionCode_PropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'CI_OnLineFunctionCode'), CodeListValue_Type, scope=CI_OnLineFunctionCode_PropertyType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 257, 1)))

def _BuildAutomaton_171 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_171
    del _BuildAutomaton_171
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 260, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(CI_OnLineFunctionCode_PropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'CI_OnLineFunctionCode')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 261, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
CI_OnLineFunctionCode_PropertyType._Automaton = _BuildAutomaton_171()




CI_DateTypeCode_PropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'CI_DateTypeCode'), CodeListValue_Type, scope=CI_DateTypeCode_PropertyType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 267, 1)))

def _BuildAutomaton_172 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_172
    del _BuildAutomaton_172
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 270, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(CI_DateTypeCode_PropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'CI_DateTypeCode')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 271, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
CI_DateTypeCode_PropertyType._Automaton = _BuildAutomaton_172()




MD_Constraints_PropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_Constraints'), MD_Constraints_Type, scope=MD_Constraints_PropertyType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/constraints.xsd', 26, 1)))

def _BuildAutomaton_173 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_173
    del _BuildAutomaton_173
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/constraints.xsd', 29, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(MD_Constraints_PropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_Constraints')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/constraints.xsd', 30, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
MD_Constraints_PropertyType._Automaton = _BuildAutomaton_173()




MD_LegalConstraints_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'accessConstraints'), MD_RestrictionCode_PropertyType, scope=MD_LegalConstraints_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/constraints.xsd', 43, 5)))

MD_LegalConstraints_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'useConstraints'), MD_RestrictionCode_PropertyType, scope=MD_LegalConstraints_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/constraints.xsd', 44, 5)))

MD_LegalConstraints_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'otherConstraints'), CharacterString_PropertyType, scope=MD_LegalConstraints_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/constraints.xsd', 45, 5)))

def _BuildAutomaton_174 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_174
    del _BuildAutomaton_174
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/constraints.xsd', 20, 5))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/constraints.xsd', 43, 5))
    counters.add(cc_1)
    cc_2 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/constraints.xsd', 44, 5))
    counters.add(cc_2)
    cc_3 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/constraints.xsd', 45, 5))
    counters.add(cc_3)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(MD_LegalConstraints_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'useLimitation')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/constraints.xsd', 20, 5))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_1, False))
    symbol = pyxb.binding.content.ElementUse(MD_LegalConstraints_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'accessConstraints')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/constraints.xsd', 43, 5))
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_2, False))
    symbol = pyxb.binding.content.ElementUse(MD_LegalConstraints_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'useConstraints')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/constraints.xsd', 44, 5))
    st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_3, False))
    symbol = pyxb.binding.content.ElementUse(MD_LegalConstraints_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'otherConstraints')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/constraints.xsd', 45, 5))
    st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_3)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_1, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_1, False) ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_2, True) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_2, False) ]))
    st_2._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_3, True) ]))
    st_3._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
MD_LegalConstraints_Type._Automaton = _BuildAutomaton_174()




MD_LegalConstraints_PropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_LegalConstraints'), MD_LegalConstraints_Type, scope=MD_LegalConstraints_PropertyType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/constraints.xsd', 51, 1)))

def _BuildAutomaton_175 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_175
    del _BuildAutomaton_175
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/constraints.xsd', 54, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(MD_LegalConstraints_PropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_LegalConstraints')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/constraints.xsd', 55, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
MD_LegalConstraints_PropertyType._Automaton = _BuildAutomaton_175()




MD_SecurityConstraints_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'classification'), MD_ClassificationCode_PropertyType, scope=MD_SecurityConstraints_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/constraints.xsd', 68, 5)))

MD_SecurityConstraints_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'userNote'), CharacterString_PropertyType, scope=MD_SecurityConstraints_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/constraints.xsd', 69, 5)))

MD_SecurityConstraints_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'classificationSystem'), CharacterString_PropertyType, scope=MD_SecurityConstraints_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/constraints.xsd', 70, 5)))

MD_SecurityConstraints_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'handlingDescription'), CharacterString_PropertyType, scope=MD_SecurityConstraints_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/constraints.xsd', 71, 5)))

def _BuildAutomaton_176 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_176
    del _BuildAutomaton_176
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/constraints.xsd', 20, 5))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/constraints.xsd', 69, 5))
    counters.add(cc_1)
    cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/constraints.xsd', 70, 5))
    counters.add(cc_2)
    cc_3 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/constraints.xsd', 71, 5))
    counters.add(cc_3)
    states = []
    final_update = None
    symbol = pyxb.binding.content.ElementUse(MD_SecurityConstraints_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'useLimitation')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/constraints.xsd', 20, 5))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(MD_SecurityConstraints_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'classification')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/constraints.xsd', 68, 5))
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_1, False))
    symbol = pyxb.binding.content.ElementUse(MD_SecurityConstraints_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'userNote')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/constraints.xsd', 69, 5))
    st_2 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_2, False))
    symbol = pyxb.binding.content.ElementUse(MD_SecurityConstraints_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'classificationSystem')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/constraints.xsd', 70, 5))
    st_3 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_3)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_3, False))
    symbol = pyxb.binding.content.ElementUse(MD_SecurityConstraints_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'handlingDescription')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/constraints.xsd', 71, 5))
    st_4 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_4)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_2, [
         ]))
    transitions.append(fac.Transition(st_3, [
         ]))
    transitions.append(fac.Transition(st_4, [
         ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_1, True) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_1, False) ]))
    st_2._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_2, True) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_2, False) ]))
    st_3._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_3, True) ]))
    st_4._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
MD_SecurityConstraints_Type._Automaton = _BuildAutomaton_176()




MD_SecurityConstraints_PropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_SecurityConstraints'), MD_SecurityConstraints_Type, scope=MD_SecurityConstraints_PropertyType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/constraints.xsd', 77, 1)))

def _BuildAutomaton_177 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_177
    del _BuildAutomaton_177
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/constraints.xsd', 80, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(MD_SecurityConstraints_PropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_SecurityConstraints')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/constraints.xsd', 81, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
MD_SecurityConstraints_PropertyType._Automaton = _BuildAutomaton_177()




MD_ClassificationCode_PropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_ClassificationCode'), CodeListValue_Type, scope=MD_ClassificationCode_PropertyType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/constraints.xsd', 88, 1)))

def _BuildAutomaton_178 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_178
    del _BuildAutomaton_178
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/constraints.xsd', 91, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(MD_ClassificationCode_PropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_ClassificationCode')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/constraints.xsd', 92, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
MD_ClassificationCode_PropertyType._Automaton = _BuildAutomaton_178()




MD_RestrictionCode_PropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_RestrictionCode'), CodeListValue_Type, scope=MD_RestrictionCode_PropertyType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/constraints.xsd', 98, 1)))

def _BuildAutomaton_179 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_179
    del _BuildAutomaton_179
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/constraints.xsd', 101, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(MD_RestrictionCode_PropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_RestrictionCode')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/constraints.xsd', 102, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
MD_RestrictionCode_PropertyType._Automaton = _BuildAutomaton_179()




MD_FeatureCatalogueDescription_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'complianceCode'), Boolean_PropertyType, scope=MD_FeatureCatalogueDescription_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/content.xsd', 22, 5)))

MD_FeatureCatalogueDescription_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'language'), CharacterString_PropertyType, scope=MD_FeatureCatalogueDescription_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/content.xsd', 23, 5)))

MD_FeatureCatalogueDescription_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'includedWithDataset'), Boolean_PropertyType, scope=MD_FeatureCatalogueDescription_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/content.xsd', 24, 5)))

MD_FeatureCatalogueDescription_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'featureTypes'), GenericName_PropertyType, scope=MD_FeatureCatalogueDescription_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/content.xsd', 25, 5)))

MD_FeatureCatalogueDescription_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'featureCatalogueCitation'), CI_Citation_PropertyType, scope=MD_FeatureCatalogueDescription_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/content.xsd', 26, 5)))

def _BuildAutomaton_180 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_180
    del _BuildAutomaton_180
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/content.xsd', 22, 5))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/content.xsd', 23, 5))
    counters.add(cc_1)
    cc_2 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/content.xsd', 25, 5))
    counters.add(cc_2)
    states = []
    final_update = None
    symbol = pyxb.binding.content.ElementUse(MD_FeatureCatalogueDescription_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'complianceCode')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/content.xsd', 22, 5))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(MD_FeatureCatalogueDescription_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'language')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/content.xsd', 23, 5))
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(MD_FeatureCatalogueDescription_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'includedWithDataset')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/content.xsd', 24, 5))
    st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(MD_FeatureCatalogueDescription_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'featureTypes')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/content.xsd', 25, 5))
    st_3 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_3)
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(MD_FeatureCatalogueDescription_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'featureCatalogueCitation')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/content.xsd', 26, 5))
    st_4 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_4)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_1, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_1, False) ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_3, [
         ]))
    transitions.append(fac.Transition(st_4, [
         ]))
    st_2._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_2, True) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_2, False) ]))
    st_3._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
         ]))
    st_4._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
MD_FeatureCatalogueDescription_Type._Automaton = _BuildAutomaton_180()




MD_FeatureCatalogueDescription_PropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_FeatureCatalogueDescription'), MD_FeatureCatalogueDescription_Type, scope=MD_FeatureCatalogueDescription_PropertyType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/content.xsd', 32, 1)))

def _BuildAutomaton_181 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_181
    del _BuildAutomaton_181
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/content.xsd', 35, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(MD_FeatureCatalogueDescription_PropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_FeatureCatalogueDescription')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/content.xsd', 36, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
MD_FeatureCatalogueDescription_PropertyType._Automaton = _BuildAutomaton_181()




MD_CoverageDescription_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'attributeDescription'), RecordType_PropertyType, scope=MD_CoverageDescription_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/content.xsd', 49, 5)))

MD_CoverageDescription_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'contentType'), MD_CoverageContentTypeCode_PropertyType, scope=MD_CoverageDescription_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/content.xsd', 50, 5)))

MD_CoverageDescription_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'dimension'), MD_RangeDimension_PropertyType, scope=MD_CoverageDescription_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/content.xsd', 51, 5)))

def _BuildAutomaton_182 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_182
    del _BuildAutomaton_182
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/content.xsd', 51, 5))
    counters.add(cc_0)
    states = []
    final_update = None
    symbol = pyxb.binding.content.ElementUse(MD_CoverageDescription_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'attributeDescription')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/content.xsd', 49, 5))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(MD_CoverageDescription_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'contentType')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/content.xsd', 50, 5))
    st_1 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(MD_CoverageDescription_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'dimension')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/content.xsd', 51, 5))
    st_2 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    transitions = []
    transitions.append(fac.Transition(st_1, [
         ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_2, [
         ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_2._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
MD_CoverageDescription_Type._Automaton = _BuildAutomaton_182()




MD_CoverageDescription_PropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_CoverageDescription'), MD_CoverageDescription_Type, scope=MD_CoverageDescription_PropertyType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/content.xsd', 57, 1)))

def _BuildAutomaton_183 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_183
    del _BuildAutomaton_183
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/content.xsd', 60, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(MD_CoverageDescription_PropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_CoverageDescription')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/content.xsd', 61, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
MD_CoverageDescription_PropertyType._Automaton = _BuildAutomaton_183()




MD_ImageDescription_PropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_ImageDescription'), MD_ImageDescription_Type, scope=MD_ImageDescription_PropertyType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/content.xsd', 91, 1)))

def _BuildAutomaton_184 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_184
    del _BuildAutomaton_184
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/content.xsd', 94, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(MD_ImageDescription_PropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_ImageDescription')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/content.xsd', 95, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
MD_ImageDescription_PropertyType._Automaton = _BuildAutomaton_184()




MD_ContentInformation_PropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'AbstractMD_ContentInformation'), AbstractMD_ContentInformation_Type, abstract=pyxb.binding.datatypes.boolean(1), scope=MD_ContentInformation_PropertyType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/content.xsd', 109, 1)))

def _BuildAutomaton_185 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_185
    del _BuildAutomaton_185
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/content.xsd', 112, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(MD_ContentInformation_PropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'AbstractMD_ContentInformation')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/content.xsd', 113, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
MD_ContentInformation_PropertyType._Automaton = _BuildAutomaton_185()




MD_RangeDimension_PropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_RangeDimension'), MD_RangeDimension_Type, scope=MD_RangeDimension_PropertyType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/content.xsd', 133, 1)))

def _BuildAutomaton_186 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_186
    del _BuildAutomaton_186
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/content.xsd', 136, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(MD_RangeDimension_PropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_RangeDimension')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/content.xsd', 137, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
MD_RangeDimension_PropertyType._Automaton = _BuildAutomaton_186()




MD_Band_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'maxValue'), Real_PropertyType, scope=MD_Band_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/content.xsd', 147, 5)))

MD_Band_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'minValue'), Real_PropertyType, scope=MD_Band_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/content.xsd', 148, 5)))

MD_Band_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'units'), UomLength_PropertyType, scope=MD_Band_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/content.xsd', 149, 5)))

MD_Band_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'peakResponse'), Real_PropertyType, scope=MD_Band_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/content.xsd', 150, 5)))

MD_Band_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'bitsPerValue'), Integer_PropertyType, scope=MD_Band_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/content.xsd', 151, 5)))

MD_Band_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'toneGradation'), Integer_PropertyType, scope=MD_Band_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/content.xsd', 152, 5)))

MD_Band_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'scaleFactor'), Real_PropertyType, scope=MD_Band_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/content.xsd', 153, 5)))

MD_Band_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'offset'), Real_PropertyType, scope=MD_Band_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/content.xsd', 154, 5)))

def _BuildAutomaton_187 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_187
    del _BuildAutomaton_187
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/content.xsd', 126, 5))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/content.xsd', 127, 5))
    counters.add(cc_1)
    cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/content.xsd', 147, 5))
    counters.add(cc_2)
    cc_3 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/content.xsd', 148, 5))
    counters.add(cc_3)
    cc_4 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/content.xsd', 149, 5))
    counters.add(cc_4)
    cc_5 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/content.xsd', 150, 5))
    counters.add(cc_5)
    cc_6 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/content.xsd', 151, 5))
    counters.add(cc_6)
    cc_7 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/content.xsd', 152, 5))
    counters.add(cc_7)
    cc_8 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/content.xsd', 153, 5))
    counters.add(cc_8)
    cc_9 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/content.xsd', 154, 5))
    counters.add(cc_9)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(MD_Band_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'sequenceIdentifier')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/content.xsd', 126, 5))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_1, False))
    symbol = pyxb.binding.content.ElementUse(MD_Band_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'descriptor')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/content.xsd', 127, 5))
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_2, False))
    symbol = pyxb.binding.content.ElementUse(MD_Band_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'maxValue')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/content.xsd', 147, 5))
    st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_3, False))
    symbol = pyxb.binding.content.ElementUse(MD_Band_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'minValue')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/content.xsd', 148, 5))
    st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_3)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_4, False))
    symbol = pyxb.binding.content.ElementUse(MD_Band_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'units')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/content.xsd', 149, 5))
    st_4 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_4)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_5, False))
    symbol = pyxb.binding.content.ElementUse(MD_Band_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'peakResponse')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/content.xsd', 150, 5))
    st_5 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_5)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_6, False))
    symbol = pyxb.binding.content.ElementUse(MD_Band_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'bitsPerValue')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/content.xsd', 151, 5))
    st_6 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_6)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_7, False))
    symbol = pyxb.binding.content.ElementUse(MD_Band_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'toneGradation')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/content.xsd', 152, 5))
    st_7 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_7)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_8, False))
    symbol = pyxb.binding.content.ElementUse(MD_Band_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'scaleFactor')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/content.xsd', 153, 5))
    st_8 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_8)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_9, False))
    symbol = pyxb.binding.content.ElementUse(MD_Band_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'offset')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/content.xsd', 154, 5))
    st_9 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_9)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_8, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_9, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_1, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_8, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_9, [
        fac.UpdateInstruction(cc_1, False) ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_2, True) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_8, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_9, [
        fac.UpdateInstruction(cc_2, False) ]))
    st_2._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_3, True) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_8, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_9, [
        fac.UpdateInstruction(cc_3, False) ]))
    st_3._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_4, True) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_4, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_4, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_4, False) ]))
    transitions.append(fac.Transition(st_8, [
        fac.UpdateInstruction(cc_4, False) ]))
    transitions.append(fac.Transition(st_9, [
        fac.UpdateInstruction(cc_4, False) ]))
    st_4._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_5, True) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_5, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_5, False) ]))
    transitions.append(fac.Transition(st_8, [
        fac.UpdateInstruction(cc_5, False) ]))
    transitions.append(fac.Transition(st_9, [
        fac.UpdateInstruction(cc_5, False) ]))
    st_5._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_6, True) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_6, False) ]))
    transitions.append(fac.Transition(st_8, [
        fac.UpdateInstruction(cc_6, False) ]))
    transitions.append(fac.Transition(st_9, [
        fac.UpdateInstruction(cc_6, False) ]))
    st_6._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_7, True) ]))
    transitions.append(fac.Transition(st_8, [
        fac.UpdateInstruction(cc_7, False) ]))
    transitions.append(fac.Transition(st_9, [
        fac.UpdateInstruction(cc_7, False) ]))
    st_7._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_8, [
        fac.UpdateInstruction(cc_8, True) ]))
    transitions.append(fac.Transition(st_9, [
        fac.UpdateInstruction(cc_8, False) ]))
    st_8._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_9, [
        fac.UpdateInstruction(cc_9, True) ]))
    st_9._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
MD_Band_Type._Automaton = _BuildAutomaton_187()




MD_Band_PropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_Band'), MD_Band_Type, scope=MD_Band_PropertyType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/content.xsd', 160, 1)))

def _BuildAutomaton_188 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_188
    del _BuildAutomaton_188
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/content.xsd', 163, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(MD_Band_PropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_Band')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/content.xsd', 164, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
MD_Band_PropertyType._Automaton = _BuildAutomaton_188()




MD_CoverageContentTypeCode_PropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_CoverageContentTypeCode'), CodeListValue_Type, scope=MD_CoverageContentTypeCode_PropertyType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/content.xsd', 171, 1)))

def _BuildAutomaton_189 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_189
    del _BuildAutomaton_189
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/content.xsd', 174, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(MD_CoverageContentTypeCode_PropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_CoverageContentTypeCode')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/content.xsd', 175, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
MD_CoverageContentTypeCode_PropertyType._Automaton = _BuildAutomaton_189()




MD_ImagingConditionCode_PropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_ImagingConditionCode'), CodeListValue_Type, scope=MD_ImagingConditionCode_PropertyType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/content.xsd', 181, 1)))

def _BuildAutomaton_190 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_190
    del _BuildAutomaton_190
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/content.xsd', 184, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(MD_ImagingConditionCode_PropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_ImagingConditionCode')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/content.xsd', 185, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
MD_ImagingConditionCode_PropertyType._Automaton = _BuildAutomaton_190()




LI_ProcessStep_PropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'LI_ProcessStep'), LI_ProcessStep_Type, scope=LI_ProcessStep_PropertyType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 29, 1)))

def _BuildAutomaton_191 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_191
    del _BuildAutomaton_191
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 32, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(LI_ProcessStep_PropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'LI_ProcessStep')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 33, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
LI_ProcessStep_PropertyType._Automaton = _BuildAutomaton_191()




LI_Source_PropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'LI_Source'), LI_Source_Type, scope=LI_Source_PropertyType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 54, 1)))

def _BuildAutomaton_192 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_192
    del _BuildAutomaton_192
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 57, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(LI_Source_PropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'LI_Source')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 58, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
LI_Source_PropertyType._Automaton = _BuildAutomaton_192()




LI_Lineage_PropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'LI_Lineage'), LI_Lineage_Type, scope=LI_Lineage_PropertyType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 76, 1)))

def _BuildAutomaton_193 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_193
    del _BuildAutomaton_193
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 79, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(LI_Lineage_PropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'LI_Lineage')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 80, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
LI_Lineage_PropertyType._Automaton = _BuildAutomaton_193()




DQ_ConformanceResult_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'specification'), CI_Citation_PropertyType, scope=DQ_ConformanceResult_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 93, 5)))

DQ_ConformanceResult_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'explanation'), CharacterString_PropertyType, scope=DQ_ConformanceResult_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 94, 5)))

DQ_ConformanceResult_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'pass'), Boolean_PropertyType, scope=DQ_ConformanceResult_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 95, 5)))

def _BuildAutomaton_194 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_194
    del _BuildAutomaton_194
    import pyxb.utils.fac as fac

    counters = set()
    states = []
    final_update = None
    symbol = pyxb.binding.content.ElementUse(DQ_ConformanceResult_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'specification')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 93, 5))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(DQ_ConformanceResult_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'explanation')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 94, 5))
    st_1 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(DQ_ConformanceResult_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'pass')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 95, 5))
    st_2 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    transitions = []
    transitions.append(fac.Transition(st_1, [
         ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_2, [
         ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    st_2._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
DQ_ConformanceResult_Type._Automaton = _BuildAutomaton_194()




DQ_ConformanceResult_PropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'DQ_ConformanceResult'), DQ_ConformanceResult_Type, scope=DQ_ConformanceResult_PropertyType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 101, 1)))

def _BuildAutomaton_195 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_195
    del _BuildAutomaton_195
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 104, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(DQ_ConformanceResult_PropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'DQ_ConformanceResult')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 105, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
DQ_ConformanceResult_PropertyType._Automaton = _BuildAutomaton_195()




DQ_QuantitativeResult_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'valueType'), RecordType_PropertyType, scope=DQ_QuantitativeResult_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 118, 5)))

DQ_QuantitativeResult_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'valueUnit'), UnitOfMeasure_PropertyType, scope=DQ_QuantitativeResult_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 119, 5)))

DQ_QuantitativeResult_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'errorStatistic'), CharacterString_PropertyType, scope=DQ_QuantitativeResult_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 120, 5)))

DQ_QuantitativeResult_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'value'), Record_PropertyType, scope=DQ_QuantitativeResult_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 121, 5)))

def _BuildAutomaton_196 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_196
    del _BuildAutomaton_196
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 118, 5))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 120, 5))
    counters.add(cc_1)
    states = []
    final_update = None
    symbol = pyxb.binding.content.ElementUse(DQ_QuantitativeResult_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'valueType')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 118, 5))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(DQ_QuantitativeResult_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'valueUnit')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 119, 5))
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(DQ_QuantitativeResult_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'errorStatistic')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 120, 5))
    st_2 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(DQ_QuantitativeResult_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'value')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 121, 5))
    st_3 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_3)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_2, [
         ]))
    transitions.append(fac.Transition(st_3, [
         ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_1, True) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_1, False) ]))
    st_2._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_3, [
         ]))
    st_3._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
DQ_QuantitativeResult_Type._Automaton = _BuildAutomaton_196()




DQ_QuantitativeResult_PropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'DQ_QuantitativeResult'), DQ_QuantitativeResult_Type, scope=DQ_QuantitativeResult_PropertyType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 127, 1)))

def _BuildAutomaton_197 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_197
    del _BuildAutomaton_197
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 130, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(DQ_QuantitativeResult_PropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'DQ_QuantitativeResult')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 131, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
DQ_QuantitativeResult_PropertyType._Automaton = _BuildAutomaton_197()




DQ_Result_PropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'AbstractDQ_Result'), AbstractDQ_Result_Type, abstract=pyxb.binding.datatypes.boolean(1), scope=DQ_Result_PropertyType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 145, 1)))

def _BuildAutomaton_198 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_198
    del _BuildAutomaton_198
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 148, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(DQ_Result_PropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'AbstractDQ_Result')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 149, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
DQ_Result_PropertyType._Automaton = _BuildAutomaton_198()




DQ_TemporalValidity_PropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'DQ_TemporalValidity'), DQ_TemporalValidity_Type, scope=DQ_TemporalValidity_PropertyType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 161, 1)))

def _BuildAutomaton_199 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_199
    del _BuildAutomaton_199
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 164, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(DQ_TemporalValidity_PropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'DQ_TemporalValidity')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 165, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
DQ_TemporalValidity_PropertyType._Automaton = _BuildAutomaton_199()




DQ_TemporalConsistency_PropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'DQ_TemporalConsistency'), DQ_TemporalConsistency_Type, scope=DQ_TemporalConsistency_PropertyType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 177, 1)))

def _BuildAutomaton_200 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_200
    del _BuildAutomaton_200
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 180, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(DQ_TemporalConsistency_PropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'DQ_TemporalConsistency')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 181, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
DQ_TemporalConsistency_PropertyType._Automaton = _BuildAutomaton_200()




DQ_AccuracyOfATimeMeasurement_PropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'DQ_AccuracyOfATimeMeasurement'), DQ_AccuracyOfATimeMeasurement_Type, scope=DQ_AccuracyOfATimeMeasurement_PropertyType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 193, 1)))

def _BuildAutomaton_201 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_201
    del _BuildAutomaton_201
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 196, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(DQ_AccuracyOfATimeMeasurement_PropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'DQ_AccuracyOfATimeMeasurement')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 197, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
DQ_AccuracyOfATimeMeasurement_PropertyType._Automaton = _BuildAutomaton_201()




DQ_QuantitativeAttributeAccuracy_PropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'DQ_QuantitativeAttributeAccuracy'), DQ_QuantitativeAttributeAccuracy_Type, scope=DQ_QuantitativeAttributeAccuracy_PropertyType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 209, 1)))

def _BuildAutomaton_202 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_202
    del _BuildAutomaton_202
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 212, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(DQ_QuantitativeAttributeAccuracy_PropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'DQ_QuantitativeAttributeAccuracy')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 213, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
DQ_QuantitativeAttributeAccuracy_PropertyType._Automaton = _BuildAutomaton_202()




DQ_NonQuantitativeAttributeAccuracy_PropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'DQ_NonQuantitativeAttributeAccuracy'), DQ_NonQuantitativeAttributeAccuracy_Type, scope=DQ_NonQuantitativeAttributeAccuracy_PropertyType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 225, 1)))

def _BuildAutomaton_203 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_203
    del _BuildAutomaton_203
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 228, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(DQ_NonQuantitativeAttributeAccuracy_PropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'DQ_NonQuantitativeAttributeAccuracy')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 229, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
DQ_NonQuantitativeAttributeAccuracy_PropertyType._Automaton = _BuildAutomaton_203()




DQ_ThematicClassificationCorrectness_PropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'DQ_ThematicClassificationCorrectness'), DQ_ThematicClassificationCorrectness_Type, scope=DQ_ThematicClassificationCorrectness_PropertyType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 241, 1)))

def _BuildAutomaton_204 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_204
    del _BuildAutomaton_204
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 244, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(DQ_ThematicClassificationCorrectness_PropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'DQ_ThematicClassificationCorrectness')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 245, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
DQ_ThematicClassificationCorrectness_PropertyType._Automaton = _BuildAutomaton_204()




DQ_RelativeInternalPositionalAccuracy_PropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'DQ_RelativeInternalPositionalAccuracy'), DQ_RelativeInternalPositionalAccuracy_Type, scope=DQ_RelativeInternalPositionalAccuracy_PropertyType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 257, 1)))

def _BuildAutomaton_205 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_205
    del _BuildAutomaton_205
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 260, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(DQ_RelativeInternalPositionalAccuracy_PropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'DQ_RelativeInternalPositionalAccuracy')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 261, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
DQ_RelativeInternalPositionalAccuracy_PropertyType._Automaton = _BuildAutomaton_205()




DQ_GriddedDataPositionalAccuracy_PropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'DQ_GriddedDataPositionalAccuracy'), DQ_GriddedDataPositionalAccuracy_Type, scope=DQ_GriddedDataPositionalAccuracy_PropertyType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 273, 1)))

def _BuildAutomaton_206 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_206
    del _BuildAutomaton_206
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 276, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(DQ_GriddedDataPositionalAccuracy_PropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'DQ_GriddedDataPositionalAccuracy')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 277, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
DQ_GriddedDataPositionalAccuracy_PropertyType._Automaton = _BuildAutomaton_206()




DQ_AbsoluteExternalPositionalAccuracy_PropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'DQ_AbsoluteExternalPositionalAccuracy'), DQ_AbsoluteExternalPositionalAccuracy_Type, scope=DQ_AbsoluteExternalPositionalAccuracy_PropertyType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 289, 1)))

def _BuildAutomaton_207 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_207
    del _BuildAutomaton_207
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 292, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(DQ_AbsoluteExternalPositionalAccuracy_PropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'DQ_AbsoluteExternalPositionalAccuracy')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 293, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
DQ_AbsoluteExternalPositionalAccuracy_PropertyType._Automaton = _BuildAutomaton_207()




DQ_TopologicalConsistency_PropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'DQ_TopologicalConsistency'), DQ_TopologicalConsistency_Type, scope=DQ_TopologicalConsistency_PropertyType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 305, 1)))

def _BuildAutomaton_208 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_208
    del _BuildAutomaton_208
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 308, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(DQ_TopologicalConsistency_PropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'DQ_TopologicalConsistency')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 309, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
DQ_TopologicalConsistency_PropertyType._Automaton = _BuildAutomaton_208()




DQ_FormatConsistency_PropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'DQ_FormatConsistency'), DQ_FormatConsistency_Type, scope=DQ_FormatConsistency_PropertyType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 321, 1)))

def _BuildAutomaton_209 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_209
    del _BuildAutomaton_209
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 324, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(DQ_FormatConsistency_PropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'DQ_FormatConsistency')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 325, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
DQ_FormatConsistency_PropertyType._Automaton = _BuildAutomaton_209()




DQ_DomainConsistency_PropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'DQ_DomainConsistency'), DQ_DomainConsistency_Type, scope=DQ_DomainConsistency_PropertyType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 337, 1)))

def _BuildAutomaton_210 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_210
    del _BuildAutomaton_210
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 340, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(DQ_DomainConsistency_PropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'DQ_DomainConsistency')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 341, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
DQ_DomainConsistency_PropertyType._Automaton = _BuildAutomaton_210()




DQ_ConceptualConsistency_PropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'DQ_ConceptualConsistency'), DQ_ConceptualConsistency_Type, scope=DQ_ConceptualConsistency_PropertyType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 353, 1)))

def _BuildAutomaton_211 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_211
    del _BuildAutomaton_211
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 356, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(DQ_ConceptualConsistency_PropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'DQ_ConceptualConsistency')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 357, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
DQ_ConceptualConsistency_PropertyType._Automaton = _BuildAutomaton_211()




DQ_CompletenessOmission_PropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'DQ_CompletenessOmission'), DQ_CompletenessOmission_Type, scope=DQ_CompletenessOmission_PropertyType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 369, 1)))

def _BuildAutomaton_212 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_212
    del _BuildAutomaton_212
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 372, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(DQ_CompletenessOmission_PropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'DQ_CompletenessOmission')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 373, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
DQ_CompletenessOmission_PropertyType._Automaton = _BuildAutomaton_212()




DQ_CompletenessCommission_PropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'DQ_CompletenessCommission'), DQ_CompletenessCommission_Type, scope=DQ_CompletenessCommission_PropertyType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 385, 1)))

def _BuildAutomaton_213 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_213
    del _BuildAutomaton_213
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 388, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(DQ_CompletenessCommission_PropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'DQ_CompletenessCommission')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 389, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
DQ_CompletenessCommission_PropertyType._Automaton = _BuildAutomaton_213()




def _BuildAutomaton_214 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_214
    del _BuildAutomaton_214
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 479, 5))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 480, 5))
    counters.add(cc_1)
    cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 481, 5))
    counters.add(cc_2)
    cc_3 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 482, 5))
    counters.add(cc_3)
    cc_4 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 483, 5))
    counters.add(cc_4)
    cc_5 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 484, 5))
    counters.add(cc_5)
    cc_6 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 485, 5))
    counters.add(cc_6)
    cc_7 = fac.CounterCondition(min=1, max=2, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 486, 5))
    counters.add(cc_7)
    states = []
    final_update = None
    symbol = pyxb.binding.content.ElementUse(AbstractDQ_TemporalAccuracy_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'nameOfMeasure')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 479, 5))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(AbstractDQ_TemporalAccuracy_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'measureIdentification')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 480, 5))
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(AbstractDQ_TemporalAccuracy_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'measureDescription')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 481, 5))
    st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(AbstractDQ_TemporalAccuracy_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'evaluationMethodType')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 482, 5))
    st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_3)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(AbstractDQ_TemporalAccuracy_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'evaluationMethodDescription')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 483, 5))
    st_4 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_4)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(AbstractDQ_TemporalAccuracy_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'evaluationProcedure')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 484, 5))
    st_5 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_5)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(AbstractDQ_TemporalAccuracy_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'dateTime')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 485, 5))
    st_6 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_6)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_7, False))
    symbol = pyxb.binding.content.ElementUse(AbstractDQ_TemporalAccuracy_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'result')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 486, 5))
    st_7 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_7)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_1, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_1, False) ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_2, True) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_2, False) ]))
    st_2._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_3, True) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_3, False) ]))
    st_3._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_4, True) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_4, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_4, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_4, False) ]))
    st_4._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_5, True) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_5, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_5, False) ]))
    st_5._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_6, True) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_6, False) ]))
    st_6._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_7, True) ]))
    st_7._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
AbstractDQ_TemporalAccuracy_Type._Automaton = _BuildAutomaton_214()




DQ_TemporalAccuracy_PropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'AbstractDQ_TemporalAccuracy'), AbstractDQ_TemporalAccuracy_Type, abstract=pyxb.binding.datatypes.boolean(1), scope=DQ_TemporalAccuracy_PropertyType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 401, 1)))

def _BuildAutomaton_215 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_215
    del _BuildAutomaton_215
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 404, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(DQ_TemporalAccuracy_PropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'AbstractDQ_TemporalAccuracy')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 405, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
DQ_TemporalAccuracy_PropertyType._Automaton = _BuildAutomaton_215()




def _BuildAutomaton_216 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_216
    del _BuildAutomaton_216
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 479, 5))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 480, 5))
    counters.add(cc_1)
    cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 481, 5))
    counters.add(cc_2)
    cc_3 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 482, 5))
    counters.add(cc_3)
    cc_4 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 483, 5))
    counters.add(cc_4)
    cc_5 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 484, 5))
    counters.add(cc_5)
    cc_6 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 485, 5))
    counters.add(cc_6)
    cc_7 = fac.CounterCondition(min=1, max=2, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 486, 5))
    counters.add(cc_7)
    states = []
    final_update = None
    symbol = pyxb.binding.content.ElementUse(AbstractDQ_ThematicAccuracy_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'nameOfMeasure')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 479, 5))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(AbstractDQ_ThematicAccuracy_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'measureIdentification')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 480, 5))
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(AbstractDQ_ThematicAccuracy_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'measureDescription')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 481, 5))
    st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(AbstractDQ_ThematicAccuracy_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'evaluationMethodType')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 482, 5))
    st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_3)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(AbstractDQ_ThematicAccuracy_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'evaluationMethodDescription')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 483, 5))
    st_4 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_4)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(AbstractDQ_ThematicAccuracy_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'evaluationProcedure')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 484, 5))
    st_5 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_5)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(AbstractDQ_ThematicAccuracy_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'dateTime')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 485, 5))
    st_6 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_6)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_7, False))
    symbol = pyxb.binding.content.ElementUse(AbstractDQ_ThematicAccuracy_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'result')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 486, 5))
    st_7 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_7)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_1, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_1, False) ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_2, True) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_2, False) ]))
    st_2._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_3, True) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_3, False) ]))
    st_3._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_4, True) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_4, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_4, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_4, False) ]))
    st_4._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_5, True) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_5, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_5, False) ]))
    st_5._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_6, True) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_6, False) ]))
    st_6._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_7, True) ]))
    st_7._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
AbstractDQ_ThematicAccuracy_Type._Automaton = _BuildAutomaton_216()




DQ_ThematicAccuracy_PropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'AbstractDQ_ThematicAccuracy'), AbstractDQ_ThematicAccuracy_Type, abstract=pyxb.binding.datatypes.boolean(1), scope=DQ_ThematicAccuracy_PropertyType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 417, 1)))

def _BuildAutomaton_217 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_217
    del _BuildAutomaton_217
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 420, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(DQ_ThematicAccuracy_PropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'AbstractDQ_ThematicAccuracy')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 421, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
DQ_ThematicAccuracy_PropertyType._Automaton = _BuildAutomaton_217()




def _BuildAutomaton_218 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_218
    del _BuildAutomaton_218
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 479, 5))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 480, 5))
    counters.add(cc_1)
    cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 481, 5))
    counters.add(cc_2)
    cc_3 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 482, 5))
    counters.add(cc_3)
    cc_4 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 483, 5))
    counters.add(cc_4)
    cc_5 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 484, 5))
    counters.add(cc_5)
    cc_6 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 485, 5))
    counters.add(cc_6)
    cc_7 = fac.CounterCondition(min=1, max=2, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 486, 5))
    counters.add(cc_7)
    states = []
    final_update = None
    symbol = pyxb.binding.content.ElementUse(AbstractDQ_PositionalAccuracy_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'nameOfMeasure')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 479, 5))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(AbstractDQ_PositionalAccuracy_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'measureIdentification')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 480, 5))
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(AbstractDQ_PositionalAccuracy_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'measureDescription')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 481, 5))
    st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(AbstractDQ_PositionalAccuracy_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'evaluationMethodType')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 482, 5))
    st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_3)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(AbstractDQ_PositionalAccuracy_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'evaluationMethodDescription')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 483, 5))
    st_4 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_4)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(AbstractDQ_PositionalAccuracy_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'evaluationProcedure')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 484, 5))
    st_5 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_5)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(AbstractDQ_PositionalAccuracy_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'dateTime')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 485, 5))
    st_6 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_6)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_7, False))
    symbol = pyxb.binding.content.ElementUse(AbstractDQ_PositionalAccuracy_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'result')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 486, 5))
    st_7 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_7)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_1, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_1, False) ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_2, True) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_2, False) ]))
    st_2._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_3, True) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_3, False) ]))
    st_3._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_4, True) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_4, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_4, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_4, False) ]))
    st_4._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_5, True) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_5, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_5, False) ]))
    st_5._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_6, True) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_6, False) ]))
    st_6._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_7, True) ]))
    st_7._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
AbstractDQ_PositionalAccuracy_Type._Automaton = _BuildAutomaton_218()




DQ_PositionalAccuracy_PropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'AbstractDQ_PositionalAccuracy'), AbstractDQ_PositionalAccuracy_Type, abstract=pyxb.binding.datatypes.boolean(1), scope=DQ_PositionalAccuracy_PropertyType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 433, 1)))

def _BuildAutomaton_219 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_219
    del _BuildAutomaton_219
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 436, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(DQ_PositionalAccuracy_PropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'AbstractDQ_PositionalAccuracy')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 437, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
DQ_PositionalAccuracy_PropertyType._Automaton = _BuildAutomaton_219()




def _BuildAutomaton_220 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_220
    del _BuildAutomaton_220
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 479, 5))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 480, 5))
    counters.add(cc_1)
    cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 481, 5))
    counters.add(cc_2)
    cc_3 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 482, 5))
    counters.add(cc_3)
    cc_4 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 483, 5))
    counters.add(cc_4)
    cc_5 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 484, 5))
    counters.add(cc_5)
    cc_6 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 485, 5))
    counters.add(cc_6)
    cc_7 = fac.CounterCondition(min=1, max=2, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 486, 5))
    counters.add(cc_7)
    states = []
    final_update = None
    symbol = pyxb.binding.content.ElementUse(AbstractDQ_LogicalConsistency_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'nameOfMeasure')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 479, 5))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(AbstractDQ_LogicalConsistency_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'measureIdentification')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 480, 5))
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(AbstractDQ_LogicalConsistency_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'measureDescription')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 481, 5))
    st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(AbstractDQ_LogicalConsistency_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'evaluationMethodType')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 482, 5))
    st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_3)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(AbstractDQ_LogicalConsistency_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'evaluationMethodDescription')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 483, 5))
    st_4 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_4)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(AbstractDQ_LogicalConsistency_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'evaluationProcedure')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 484, 5))
    st_5 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_5)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(AbstractDQ_LogicalConsistency_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'dateTime')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 485, 5))
    st_6 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_6)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_7, False))
    symbol = pyxb.binding.content.ElementUse(AbstractDQ_LogicalConsistency_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'result')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 486, 5))
    st_7 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_7)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_1, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_1, False) ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_2, True) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_2, False) ]))
    st_2._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_3, True) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_3, False) ]))
    st_3._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_4, True) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_4, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_4, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_4, False) ]))
    st_4._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_5, True) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_5, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_5, False) ]))
    st_5._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_6, True) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_6, False) ]))
    st_6._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_7, True) ]))
    st_7._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
AbstractDQ_LogicalConsistency_Type._Automaton = _BuildAutomaton_220()




DQ_LogicalConsistency_PropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'AbstractDQ_LogicalConsistency'), AbstractDQ_LogicalConsistency_Type, abstract=pyxb.binding.datatypes.boolean(1), scope=DQ_LogicalConsistency_PropertyType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 449, 1)))

def _BuildAutomaton_221 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_221
    del _BuildAutomaton_221
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 452, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(DQ_LogicalConsistency_PropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'AbstractDQ_LogicalConsistency')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 453, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
DQ_LogicalConsistency_PropertyType._Automaton = _BuildAutomaton_221()




def _BuildAutomaton_222 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_222
    del _BuildAutomaton_222
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 479, 5))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 480, 5))
    counters.add(cc_1)
    cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 481, 5))
    counters.add(cc_2)
    cc_3 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 482, 5))
    counters.add(cc_3)
    cc_4 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 483, 5))
    counters.add(cc_4)
    cc_5 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 484, 5))
    counters.add(cc_5)
    cc_6 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 485, 5))
    counters.add(cc_6)
    cc_7 = fac.CounterCondition(min=1, max=2, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 486, 5))
    counters.add(cc_7)
    states = []
    final_update = None
    symbol = pyxb.binding.content.ElementUse(AbstractDQ_Completeness_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'nameOfMeasure')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 479, 5))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(AbstractDQ_Completeness_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'measureIdentification')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 480, 5))
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(AbstractDQ_Completeness_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'measureDescription')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 481, 5))
    st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(AbstractDQ_Completeness_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'evaluationMethodType')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 482, 5))
    st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_3)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(AbstractDQ_Completeness_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'evaluationMethodDescription')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 483, 5))
    st_4 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_4)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(AbstractDQ_Completeness_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'evaluationProcedure')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 484, 5))
    st_5 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_5)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(AbstractDQ_Completeness_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'dateTime')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 485, 5))
    st_6 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_6)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_7, False))
    symbol = pyxb.binding.content.ElementUse(AbstractDQ_Completeness_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'result')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 486, 5))
    st_7 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_7)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_1, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_1, False) ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_2, True) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_2, False) ]))
    st_2._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_3, True) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_3, False) ]))
    st_3._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_4, True) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_4, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_4, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_4, False) ]))
    st_4._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_5, True) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_5, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_5, False) ]))
    st_5._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_6, True) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_6, False) ]))
    st_6._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_7, True) ]))
    st_7._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
AbstractDQ_Completeness_Type._Automaton = _BuildAutomaton_222()




DQ_Completeness_PropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'AbstractDQ_Completeness'), AbstractDQ_Completeness_Type, abstract=pyxb.binding.datatypes.boolean(1), scope=DQ_Completeness_PropertyType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 465, 1)))

def _BuildAutomaton_223 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_223
    del _BuildAutomaton_223
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 468, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(DQ_Completeness_PropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'AbstractDQ_Completeness')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 469, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
DQ_Completeness_PropertyType._Automaton = _BuildAutomaton_223()




DQ_Element_PropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'AbstractDQ_Element'), AbstractDQ_Element_Type, abstract=pyxb.binding.datatypes.boolean(1), scope=DQ_Element_PropertyType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 492, 1)))

def _BuildAutomaton_224 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_224
    del _BuildAutomaton_224
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 495, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(DQ_Element_PropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'AbstractDQ_Element')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 496, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
DQ_Element_PropertyType._Automaton = _BuildAutomaton_224()




DQ_DataQuality_PropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'DQ_DataQuality'), DQ_DataQuality_Type, scope=DQ_DataQuality_PropertyType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 514, 1)))

def _BuildAutomaton_225 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_225
    del _BuildAutomaton_225
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 517, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(DQ_DataQuality_PropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'DQ_DataQuality')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 518, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
DQ_DataQuality_PropertyType._Automaton = _BuildAutomaton_225()




DQ_Scope_PropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'DQ_Scope'), DQ_Scope_Type, scope=DQ_Scope_PropertyType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 536, 1)))

def _BuildAutomaton_226 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_226
    del _BuildAutomaton_226
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 539, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(DQ_Scope_PropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'DQ_Scope')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 540, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
DQ_Scope_PropertyType._Automaton = _BuildAutomaton_226()




DQ_EvaluationMethodTypeCode_PropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'DQ_EvaluationMethodTypeCode'), CodeListValue_Type, scope=DQ_EvaluationMethodTypeCode_PropertyType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 547, 1)))

def _BuildAutomaton_227 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_227
    del _BuildAutomaton_227
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 550, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(DQ_EvaluationMethodTypeCode_PropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'DQ_EvaluationMethodTypeCode')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 551, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
DQ_EvaluationMethodTypeCode_PropertyType._Automaton = _BuildAutomaton_227()




MD_Medium_PropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_Medium'), MD_Medium_Type, scope=MD_Medium_PropertyType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/distribution.xsd', 32, 1)))

def _BuildAutomaton_228 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_228
    del _BuildAutomaton_228
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/distribution.xsd', 35, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(MD_Medium_PropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_Medium')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/distribution.xsd', 36, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
MD_Medium_PropertyType._Automaton = _BuildAutomaton_228()




MD_DigitalTransferOptions_PropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_DigitalTransferOptions'), MD_DigitalTransferOptions_Type, scope=MD_DigitalTransferOptions_PropertyType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/distribution.xsd', 58, 1)))

def _BuildAutomaton_229 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_229
    del _BuildAutomaton_229
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/distribution.xsd', 61, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(MD_DigitalTransferOptions_PropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_DigitalTransferOptions')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/distribution.xsd', 62, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
MD_DigitalTransferOptions_PropertyType._Automaton = _BuildAutomaton_229()




MD_StandardOrderProcess_PropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_StandardOrderProcess'), MD_StandardOrderProcess_Type, scope=MD_StandardOrderProcess_PropertyType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/distribution.xsd', 84, 1)))

def _BuildAutomaton_230 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_230
    del _BuildAutomaton_230
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/distribution.xsd', 87, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(MD_StandardOrderProcess_PropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_StandardOrderProcess')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/distribution.xsd', 88, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
MD_StandardOrderProcess_PropertyType._Automaton = _BuildAutomaton_230()




MD_Distributor_PropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_Distributor'), MD_Distributor_Type, scope=MD_Distributor_PropertyType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/distribution.xsd', 110, 1)))

def _BuildAutomaton_231 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_231
    del _BuildAutomaton_231
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/distribution.xsd', 113, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(MD_Distributor_PropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_Distributor')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/distribution.xsd', 114, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
MD_Distributor_PropertyType._Automaton = _BuildAutomaton_231()




MD_Distribution_PropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_Distribution'), MD_Distribution_Type, scope=MD_Distribution_PropertyType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/distribution.xsd', 135, 1)))

def _BuildAutomaton_232 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_232
    del _BuildAutomaton_232
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/distribution.xsd', 138, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(MD_Distribution_PropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_Distribution')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/distribution.xsd', 139, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
MD_Distribution_PropertyType._Automaton = _BuildAutomaton_232()




MD_Format_PropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_Format'), MD_Format_Type, scope=MD_Format_PropertyType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/distribution.xsd', 163, 1)))

def _BuildAutomaton_233 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_233
    del _BuildAutomaton_233
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/distribution.xsd', 166, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(MD_Format_PropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_Format')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/distribution.xsd', 167, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
MD_Format_PropertyType._Automaton = _BuildAutomaton_233()




MD_DistributionUnits_PropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_DistributionUnits'), CodeListValue_Type, scope=MD_DistributionUnits_PropertyType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/distribution.xsd', 174, 1)))

def _BuildAutomaton_234 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_234
    del _BuildAutomaton_234
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/distribution.xsd', 177, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(MD_DistributionUnits_PropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_DistributionUnits')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/distribution.xsd', 178, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
MD_DistributionUnits_PropertyType._Automaton = _BuildAutomaton_234()




MD_MediumFormatCode_PropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_MediumFormatCode'), CodeListValue_Type, scope=MD_MediumFormatCode_PropertyType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/distribution.xsd', 184, 1)))

def _BuildAutomaton_235 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_235
    del _BuildAutomaton_235
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/distribution.xsd', 187, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(MD_MediumFormatCode_PropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_MediumFormatCode')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/distribution.xsd', 188, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
MD_MediumFormatCode_PropertyType._Automaton = _BuildAutomaton_235()




MD_MediumNameCode_PropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_MediumNameCode'), CodeListValue_Type, scope=MD_MediumNameCode_PropertyType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/distribution.xsd', 194, 1)))

def _BuildAutomaton_236 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_236
    del _BuildAutomaton_236
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/distribution.xsd', 197, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(MD_MediumNameCode_PropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_MediumNameCode')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/distribution.xsd', 198, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
MD_MediumNameCode_PropertyType._Automaton = _BuildAutomaton_236()




EX_TemporalExtent_PropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'EX_TemporalExtent'), EX_TemporalExtent_Type, scope=EX_TemporalExtent_PropertyType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/extent.xsd', 30, 1)))

def _BuildAutomaton_237 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_237
    del _BuildAutomaton_237
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/extent.xsd', 33, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(EX_TemporalExtent_PropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'EX_TemporalExtent')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/extent.xsd', 34, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
EX_TemporalExtent_PropertyType._Automaton = _BuildAutomaton_237()




EX_VerticalExtent_PropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'EX_VerticalExtent'), EX_VerticalExtent_Type, scope=EX_VerticalExtent_PropertyType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/extent.xsd', 55, 1)))

def _BuildAutomaton_238 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_238
    del _BuildAutomaton_238
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/extent.xsd', 58, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(EX_VerticalExtent_PropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'EX_VerticalExtent')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/extent.xsd', 59, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
EX_VerticalExtent_PropertyType._Automaton = _BuildAutomaton_238()




EX_BoundingPolygon_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'polygon'), GM_Object_PropertyType, scope=EX_BoundingPolygon_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/extent.xsd', 72, 5)))

def _BuildAutomaton_239 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_239
    del _BuildAutomaton_239
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/extent.xsd', 121, 5))
    counters.add(cc_0)
    states = []
    final_update = None
    symbol = pyxb.binding.content.ElementUse(EX_BoundingPolygon_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'extentTypeCode')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/extent.xsd', 121, 5))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(EX_BoundingPolygon_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'polygon')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/extent.xsd', 72, 5))
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_1, [
         ]))
    st_1._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
EX_BoundingPolygon_Type._Automaton = _BuildAutomaton_239()




EX_BoundingPolygon_PropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'EX_BoundingPolygon'), EX_BoundingPolygon_Type, scope=EX_BoundingPolygon_PropertyType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/extent.xsd', 78, 1)))

def _BuildAutomaton_240 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_240
    del _BuildAutomaton_240
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/extent.xsd', 81, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(EX_BoundingPolygon_PropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'EX_BoundingPolygon')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/extent.xsd', 82, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
EX_BoundingPolygon_PropertyType._Automaton = _BuildAutomaton_240()




EX_Extent_PropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'EX_Extent'), EX_Extent_Type, scope=EX_Extent_PropertyType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/extent.xsd', 104, 1)))

def _BuildAutomaton_241 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_241
    del _BuildAutomaton_241
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/extent.xsd', 107, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(EX_Extent_PropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'EX_Extent')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/extent.xsd', 108, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
EX_Extent_PropertyType._Automaton = _BuildAutomaton_241()




EX_GeographicExtent_PropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'AbstractEX_GeographicExtent'), AbstractEX_GeographicExtent_Type, abstract=pyxb.binding.datatypes.boolean(1), scope=EX_GeographicExtent_PropertyType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/extent.xsd', 127, 1)))

def _BuildAutomaton_242 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_242
    del _BuildAutomaton_242
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/extent.xsd', 130, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(EX_GeographicExtent_PropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'AbstractEX_GeographicExtent')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/extent.xsd', 131, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
EX_GeographicExtent_PropertyType._Automaton = _BuildAutomaton_242()




EX_GeographicBoundingBox_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'westBoundLongitude'), Decimal_PropertyType, scope=EX_GeographicBoundingBox_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/extent.xsd', 144, 5)))

EX_GeographicBoundingBox_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'eastBoundLongitude'), Decimal_PropertyType, scope=EX_GeographicBoundingBox_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/extent.xsd', 145, 5)))

EX_GeographicBoundingBox_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'southBoundLatitude'), Decimal_PropertyType, scope=EX_GeographicBoundingBox_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/extent.xsd', 146, 5)))

EX_GeographicBoundingBox_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'northBoundLatitude'), Decimal_PropertyType, scope=EX_GeographicBoundingBox_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/extent.xsd', 147, 5)))

def _BuildAutomaton_243 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_243
    del _BuildAutomaton_243
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/extent.xsd', 121, 5))
    counters.add(cc_0)
    states = []
    final_update = None
    symbol = pyxb.binding.content.ElementUse(EX_GeographicBoundingBox_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'extentTypeCode')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/extent.xsd', 121, 5))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(EX_GeographicBoundingBox_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'westBoundLongitude')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/extent.xsd', 144, 5))
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(EX_GeographicBoundingBox_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'eastBoundLongitude')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/extent.xsd', 145, 5))
    st_2 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(EX_GeographicBoundingBox_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'southBoundLatitude')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/extent.xsd', 146, 5))
    st_3 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_3)
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(EX_GeographicBoundingBox_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'northBoundLatitude')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/extent.xsd', 147, 5))
    st_4 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_4)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_2, [
         ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_3, [
         ]))
    st_2._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
         ]))
    st_3._set_transitionSet(transitions)
    transitions = []
    st_4._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
EX_GeographicBoundingBox_Type._Automaton = _BuildAutomaton_243()




EX_GeographicBoundingBox_PropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'EX_GeographicBoundingBox'), EX_GeographicBoundingBox_Type, scope=EX_GeographicBoundingBox_PropertyType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/extent.xsd', 153, 1)))

def _BuildAutomaton_244 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_244
    del _BuildAutomaton_244
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/extent.xsd', 156, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(EX_GeographicBoundingBox_PropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'EX_GeographicBoundingBox')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/extent.xsd', 157, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
EX_GeographicBoundingBox_PropertyType._Automaton = _BuildAutomaton_244()




EX_SpatialTemporalExtent_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'spatialExtent'), EX_GeographicExtent_PropertyType, scope=EX_SpatialTemporalExtent_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/extent.xsd', 170, 5)))

def _BuildAutomaton_245 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_245
    del _BuildAutomaton_245
    import pyxb.utils.fac as fac

    counters = set()
    states = []
    final_update = None
    symbol = pyxb.binding.content.ElementUse(EX_SpatialTemporalExtent_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'extent')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/extent.xsd', 24, 5))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(EX_SpatialTemporalExtent_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'spatialExtent')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/extent.xsd', 170, 5))
    st_1 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    transitions = []
    transitions.append(fac.Transition(st_1, [
         ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_1, [
         ]))
    st_1._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
EX_SpatialTemporalExtent_Type._Automaton = _BuildAutomaton_245()




EX_SpatialTemporalExtent_PropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'EX_SpatialTemporalExtent'), EX_SpatialTemporalExtent_Type, scope=EX_SpatialTemporalExtent_PropertyType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/extent.xsd', 176, 1)))

def _BuildAutomaton_246 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_246
    del _BuildAutomaton_246
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/extent.xsd', 179, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(EX_SpatialTemporalExtent_PropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'EX_SpatialTemporalExtent')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/extent.xsd', 180, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
EX_SpatialTemporalExtent_PropertyType._Automaton = _BuildAutomaton_246()




EX_GeographicDescription_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'geographicIdentifier'), MD_Identifier_PropertyType, scope=EX_GeographicDescription_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/extent.xsd', 190, 5)))

def _BuildAutomaton_247 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_247
    del _BuildAutomaton_247
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/extent.xsd', 121, 5))
    counters.add(cc_0)
    states = []
    final_update = None
    symbol = pyxb.binding.content.ElementUse(EX_GeographicDescription_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'extentTypeCode')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/extent.xsd', 121, 5))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(EX_GeographicDescription_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'geographicIdentifier')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/extent.xsd', 190, 5))
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    st_1._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
EX_GeographicDescription_Type._Automaton = _BuildAutomaton_247()




EX_GeographicDescription_PropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'EX_GeographicDescription'), EX_GeographicDescription_Type, scope=EX_GeographicDescription_PropertyType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/extent.xsd', 196, 1)))

def _BuildAutomaton_248 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_248
    del _BuildAutomaton_248
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/extent.xsd', 199, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(EX_GeographicDescription_PropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'EX_GeographicDescription')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/extent.xsd', 200, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
EX_GeographicDescription_PropertyType._Automaton = _BuildAutomaton_248()




PT_Locale_PropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'PT_Locale'), PT_Locale_Type, scope=PT_Locale_PropertyType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/freeText.xsd', 48, 1)))

def _BuildAutomaton_249 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_249
    del _BuildAutomaton_249
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/freeText.xsd', 51, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(PT_Locale_PropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'PT_Locale')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/freeText.xsd', 52, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
PT_Locale_PropertyType._Automaton = _BuildAutomaton_249()




PT_LocaleContainer_PropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'PT_LocaleContainer'), PT_LocaleContainer_Type, scope=PT_LocaleContainer_PropertyType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/freeText.xsd', 89, 1)))

def _BuildAutomaton_250 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_250
    del _BuildAutomaton_250
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/freeText.xsd', 92, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(PT_LocaleContainer_PropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'PT_LocaleContainer')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/freeText.xsd', 93, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
PT_LocaleContainer_PropertyType._Automaton = _BuildAutomaton_250()




LanguageCode_PropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'LanguageCode'), CodeListValue_Type, scope=LanguageCode_PropertyType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/freeText.xsd', 103, 1)))

def _BuildAutomaton_251 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_251
    del _BuildAutomaton_251
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/freeText.xsd', 106, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(LanguageCode_PropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'LanguageCode')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/freeText.xsd', 107, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
LanguageCode_PropertyType._Automaton = _BuildAutomaton_251()




Country_PropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'Country'), CodeListValue_Type, scope=Country_PropertyType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/freeText.xsd', 113, 1)))

def _BuildAutomaton_252 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_252
    del _BuildAutomaton_252
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/freeText.xsd', 116, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(Country_PropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'Country')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/freeText.xsd', 117, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
Country_PropertyType._Automaton = _BuildAutomaton_252()




MD_Identification_PropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'AbstractMD_Identification'), AbstractMD_Identification_Type, abstract=pyxb.binding.datatypes.boolean(1), scope=MD_Identification_PropertyType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 41, 1)))

def _BuildAutomaton_253 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_253
    del _BuildAutomaton_253
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 44, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(MD_Identification_PropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'AbstractMD_Identification')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 45, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
MD_Identification_PropertyType._Automaton = _BuildAutomaton_253()




MD_BrowseGraphic_PropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_BrowseGraphic'), MD_BrowseGraphic_Type, scope=MD_BrowseGraphic_PropertyType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 66, 1)))

def _BuildAutomaton_254 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_254
    del _BuildAutomaton_254
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 69, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(MD_BrowseGraphic_PropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_BrowseGraphic')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 70, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
MD_BrowseGraphic_PropertyType._Automaton = _BuildAutomaton_254()




MD_DataIdentification_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'spatialRepresentationType'), MD_SpatialRepresentationTypeCode_PropertyType, scope=MD_DataIdentification_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 80, 5)))

MD_DataIdentification_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'spatialResolution'), MD_Resolution_PropertyType, scope=MD_DataIdentification_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 81, 5)))

MD_DataIdentification_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'language'), CharacterString_PropertyType, scope=MD_DataIdentification_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 82, 5)))

MD_DataIdentification_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'characterSet'), MD_CharacterSetCode_PropertyType, scope=MD_DataIdentification_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 83, 5)))

MD_DataIdentification_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'topicCategory'), MD_TopicCategoryCode_PropertyType, scope=MD_DataIdentification_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 84, 5)))

MD_DataIdentification_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'environmentDescription'), CharacterString_PropertyType, scope=MD_DataIdentification_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 85, 5)))

MD_DataIdentification_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'extent'), EX_Extent_PropertyType, scope=MD_DataIdentification_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 86, 5)))

MD_DataIdentification_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'supplementalInformation'), CharacterString_PropertyType, scope=MD_DataIdentification_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 87, 5)))

def _BuildAutomaton_255 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_255
    del _BuildAutomaton_255
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 25, 5))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 26, 5))
    counters.add(cc_1)
    cc_2 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 27, 5))
    counters.add(cc_2)
    cc_3 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 28, 5))
    counters.add(cc_3)
    cc_4 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 29, 5))
    counters.add(cc_4)
    cc_5 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 30, 5))
    counters.add(cc_5)
    cc_6 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 31, 5))
    counters.add(cc_6)
    cc_7 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 32, 5))
    counters.add(cc_7)
    cc_8 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 33, 5))
    counters.add(cc_8)
    cc_9 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 34, 5))
    counters.add(cc_9)
    cc_10 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 35, 5))
    counters.add(cc_10)
    cc_11 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 80, 5))
    counters.add(cc_11)
    cc_12 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 81, 5))
    counters.add(cc_12)
    cc_13 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 83, 5))
    counters.add(cc_13)
    cc_14 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 84, 5))
    counters.add(cc_14)
    cc_15 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 85, 5))
    counters.add(cc_15)
    cc_16 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 86, 5))
    counters.add(cc_16)
    cc_17 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 87, 5))
    counters.add(cc_17)
    states = []
    final_update = None
    symbol = pyxb.binding.content.ElementUse(MD_DataIdentification_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'citation')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 23, 5))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(MD_DataIdentification_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'abstract')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 24, 5))
    st_1 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(MD_DataIdentification_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'purpose')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 25, 5))
    st_2 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(MD_DataIdentification_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'credit')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 26, 5))
    st_3 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_3)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(MD_DataIdentification_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'status')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 27, 5))
    st_4 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_4)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(MD_DataIdentification_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'pointOfContact')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 28, 5))
    st_5 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_5)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(MD_DataIdentification_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'resourceMaintenance')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 29, 5))
    st_6 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_6)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(MD_DataIdentification_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'graphicOverview')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 30, 5))
    st_7 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_7)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(MD_DataIdentification_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'resourceFormat')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 31, 5))
    st_8 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_8)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(MD_DataIdentification_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'descriptiveKeywords')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 32, 5))
    st_9 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_9)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(MD_DataIdentification_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'resourceSpecificUsage')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 33, 5))
    st_10 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_10)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(MD_DataIdentification_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'resourceConstraints')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 34, 5))
    st_11 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_11)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(MD_DataIdentification_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'aggregationInfo')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 35, 5))
    st_12 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_12)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(MD_DataIdentification_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'spatialRepresentationType')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 80, 5))
    st_13 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_13)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(MD_DataIdentification_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'spatialResolution')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 81, 5))
    st_14 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_14)
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(MD_DataIdentification_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'language')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 82, 5))
    st_15 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_15)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_13, False))
    symbol = pyxb.binding.content.ElementUse(MD_DataIdentification_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'characterSet')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 83, 5))
    st_16 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_16)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_14, False))
    symbol = pyxb.binding.content.ElementUse(MD_DataIdentification_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'topicCategory')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 84, 5))
    st_17 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_17)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_15, False))
    symbol = pyxb.binding.content.ElementUse(MD_DataIdentification_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'environmentDescription')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 85, 5))
    st_18 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_18)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_16, False))
    symbol = pyxb.binding.content.ElementUse(MD_DataIdentification_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'extent')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 86, 5))
    st_19 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_19)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_17, False))
    symbol = pyxb.binding.content.ElementUse(MD_DataIdentification_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'supplementalInformation')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 87, 5))
    st_20 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_20)
    transitions = []
    transitions.append(fac.Transition(st_1, [
         ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_2, [
         ]))
    transitions.append(fac.Transition(st_3, [
         ]))
    transitions.append(fac.Transition(st_4, [
         ]))
    transitions.append(fac.Transition(st_5, [
         ]))
    transitions.append(fac.Transition(st_6, [
         ]))
    transitions.append(fac.Transition(st_7, [
         ]))
    transitions.append(fac.Transition(st_8, [
         ]))
    transitions.append(fac.Transition(st_9, [
         ]))
    transitions.append(fac.Transition(st_10, [
         ]))
    transitions.append(fac.Transition(st_11, [
         ]))
    transitions.append(fac.Transition(st_12, [
         ]))
    transitions.append(fac.Transition(st_13, [
         ]))
    transitions.append(fac.Transition(st_14, [
         ]))
    transitions.append(fac.Transition(st_15, [
         ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_8, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_9, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_10, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_11, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_12, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_13, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_14, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_15, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_2._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_1, True) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_8, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_9, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_10, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_11, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_12, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_13, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_14, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_15, [
        fac.UpdateInstruction(cc_1, False) ]))
    st_3._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_2, True) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_8, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_9, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_10, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_11, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_12, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_13, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_14, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_15, [
        fac.UpdateInstruction(cc_2, False) ]))
    st_4._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_3, True) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_8, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_9, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_10, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_11, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_12, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_13, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_14, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_15, [
        fac.UpdateInstruction(cc_3, False) ]))
    st_5._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_4, True) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_4, False) ]))
    transitions.append(fac.Transition(st_8, [
        fac.UpdateInstruction(cc_4, False) ]))
    transitions.append(fac.Transition(st_9, [
        fac.UpdateInstruction(cc_4, False) ]))
    transitions.append(fac.Transition(st_10, [
        fac.UpdateInstruction(cc_4, False) ]))
    transitions.append(fac.Transition(st_11, [
        fac.UpdateInstruction(cc_4, False) ]))
    transitions.append(fac.Transition(st_12, [
        fac.UpdateInstruction(cc_4, False) ]))
    transitions.append(fac.Transition(st_13, [
        fac.UpdateInstruction(cc_4, False) ]))
    transitions.append(fac.Transition(st_14, [
        fac.UpdateInstruction(cc_4, False) ]))
    transitions.append(fac.Transition(st_15, [
        fac.UpdateInstruction(cc_4, False) ]))
    st_6._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_5, True) ]))
    transitions.append(fac.Transition(st_8, [
        fac.UpdateInstruction(cc_5, False) ]))
    transitions.append(fac.Transition(st_9, [
        fac.UpdateInstruction(cc_5, False) ]))
    transitions.append(fac.Transition(st_10, [
        fac.UpdateInstruction(cc_5, False) ]))
    transitions.append(fac.Transition(st_11, [
        fac.UpdateInstruction(cc_5, False) ]))
    transitions.append(fac.Transition(st_12, [
        fac.UpdateInstruction(cc_5, False) ]))
    transitions.append(fac.Transition(st_13, [
        fac.UpdateInstruction(cc_5, False) ]))
    transitions.append(fac.Transition(st_14, [
        fac.UpdateInstruction(cc_5, False) ]))
    transitions.append(fac.Transition(st_15, [
        fac.UpdateInstruction(cc_5, False) ]))
    st_7._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_8, [
        fac.UpdateInstruction(cc_6, True) ]))
    transitions.append(fac.Transition(st_9, [
        fac.UpdateInstruction(cc_6, False) ]))
    transitions.append(fac.Transition(st_10, [
        fac.UpdateInstruction(cc_6, False) ]))
    transitions.append(fac.Transition(st_11, [
        fac.UpdateInstruction(cc_6, False) ]))
    transitions.append(fac.Transition(st_12, [
        fac.UpdateInstruction(cc_6, False) ]))
    transitions.append(fac.Transition(st_13, [
        fac.UpdateInstruction(cc_6, False) ]))
    transitions.append(fac.Transition(st_14, [
        fac.UpdateInstruction(cc_6, False) ]))
    transitions.append(fac.Transition(st_15, [
        fac.UpdateInstruction(cc_6, False) ]))
    st_8._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_9, [
        fac.UpdateInstruction(cc_7, True) ]))
    transitions.append(fac.Transition(st_10, [
        fac.UpdateInstruction(cc_7, False) ]))
    transitions.append(fac.Transition(st_11, [
        fac.UpdateInstruction(cc_7, False) ]))
    transitions.append(fac.Transition(st_12, [
        fac.UpdateInstruction(cc_7, False) ]))
    transitions.append(fac.Transition(st_13, [
        fac.UpdateInstruction(cc_7, False) ]))
    transitions.append(fac.Transition(st_14, [
        fac.UpdateInstruction(cc_7, False) ]))
    transitions.append(fac.Transition(st_15, [
        fac.UpdateInstruction(cc_7, False) ]))
    st_9._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_10, [
        fac.UpdateInstruction(cc_8, True) ]))
    transitions.append(fac.Transition(st_11, [
        fac.UpdateInstruction(cc_8, False) ]))
    transitions.append(fac.Transition(st_12, [
        fac.UpdateInstruction(cc_8, False) ]))
    transitions.append(fac.Transition(st_13, [
        fac.UpdateInstruction(cc_8, False) ]))
    transitions.append(fac.Transition(st_14, [
        fac.UpdateInstruction(cc_8, False) ]))
    transitions.append(fac.Transition(st_15, [
        fac.UpdateInstruction(cc_8, False) ]))
    st_10._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_11, [
        fac.UpdateInstruction(cc_9, True) ]))
    transitions.append(fac.Transition(st_12, [
        fac.UpdateInstruction(cc_9, False) ]))
    transitions.append(fac.Transition(st_13, [
        fac.UpdateInstruction(cc_9, False) ]))
    transitions.append(fac.Transition(st_14, [
        fac.UpdateInstruction(cc_9, False) ]))
    transitions.append(fac.Transition(st_15, [
        fac.UpdateInstruction(cc_9, False) ]))
    st_11._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_12, [
        fac.UpdateInstruction(cc_10, True) ]))
    transitions.append(fac.Transition(st_13, [
        fac.UpdateInstruction(cc_10, False) ]))
    transitions.append(fac.Transition(st_14, [
        fac.UpdateInstruction(cc_10, False) ]))
    transitions.append(fac.Transition(st_15, [
        fac.UpdateInstruction(cc_10, False) ]))
    st_12._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_13, [
        fac.UpdateInstruction(cc_11, True) ]))
    transitions.append(fac.Transition(st_14, [
        fac.UpdateInstruction(cc_11, False) ]))
    transitions.append(fac.Transition(st_15, [
        fac.UpdateInstruction(cc_11, False) ]))
    st_13._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_14, [
        fac.UpdateInstruction(cc_12, True) ]))
    transitions.append(fac.Transition(st_15, [
        fac.UpdateInstruction(cc_12, False) ]))
    st_14._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_15, [
         ]))
    transitions.append(fac.Transition(st_16, [
         ]))
    transitions.append(fac.Transition(st_17, [
         ]))
    transitions.append(fac.Transition(st_18, [
         ]))
    transitions.append(fac.Transition(st_19, [
         ]))
    transitions.append(fac.Transition(st_20, [
         ]))
    st_15._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_16, [
        fac.UpdateInstruction(cc_13, True) ]))
    transitions.append(fac.Transition(st_17, [
        fac.UpdateInstruction(cc_13, False) ]))
    transitions.append(fac.Transition(st_18, [
        fac.UpdateInstruction(cc_13, False) ]))
    transitions.append(fac.Transition(st_19, [
        fac.UpdateInstruction(cc_13, False) ]))
    transitions.append(fac.Transition(st_20, [
        fac.UpdateInstruction(cc_13, False) ]))
    st_16._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_17, [
        fac.UpdateInstruction(cc_14, True) ]))
    transitions.append(fac.Transition(st_18, [
        fac.UpdateInstruction(cc_14, False) ]))
    transitions.append(fac.Transition(st_19, [
        fac.UpdateInstruction(cc_14, False) ]))
    transitions.append(fac.Transition(st_20, [
        fac.UpdateInstruction(cc_14, False) ]))
    st_17._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_18, [
        fac.UpdateInstruction(cc_15, True) ]))
    transitions.append(fac.Transition(st_19, [
        fac.UpdateInstruction(cc_15, False) ]))
    transitions.append(fac.Transition(st_20, [
        fac.UpdateInstruction(cc_15, False) ]))
    st_18._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_19, [
        fac.UpdateInstruction(cc_16, True) ]))
    transitions.append(fac.Transition(st_20, [
        fac.UpdateInstruction(cc_16, False) ]))
    st_19._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_20, [
        fac.UpdateInstruction(cc_17, True) ]))
    st_20._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
MD_DataIdentification_Type._Automaton = _BuildAutomaton_255()




MD_DataIdentification_PropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_DataIdentification'), MD_DataIdentification_Type, scope=MD_DataIdentification_PropertyType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 93, 1)))

def _BuildAutomaton_256 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_256
    del _BuildAutomaton_256
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 96, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(MD_DataIdentification_PropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_DataIdentification')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 97, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
MD_DataIdentification_PropertyType._Automaton = _BuildAutomaton_256()




def _BuildAutomaton_257 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_257
    del _BuildAutomaton_257
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 25, 5))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 26, 5))
    counters.add(cc_1)
    cc_2 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 27, 5))
    counters.add(cc_2)
    cc_3 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 28, 5))
    counters.add(cc_3)
    cc_4 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 29, 5))
    counters.add(cc_4)
    cc_5 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 30, 5))
    counters.add(cc_5)
    cc_6 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 31, 5))
    counters.add(cc_6)
    cc_7 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 32, 5))
    counters.add(cc_7)
    cc_8 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 33, 5))
    counters.add(cc_8)
    cc_9 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 34, 5))
    counters.add(cc_9)
    cc_10 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 35, 5))
    counters.add(cc_10)
    states = []
    final_update = None
    symbol = pyxb.binding.content.ElementUse(MD_ServiceIdentification_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'citation')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 23, 5))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(MD_ServiceIdentification_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'abstract')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 24, 5))
    st_1 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(MD_ServiceIdentification_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'purpose')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 25, 5))
    st_2 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_1, False))
    symbol = pyxb.binding.content.ElementUse(MD_ServiceIdentification_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'credit')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 26, 5))
    st_3 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_3)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_2, False))
    symbol = pyxb.binding.content.ElementUse(MD_ServiceIdentification_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'status')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 27, 5))
    st_4 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_4)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_3, False))
    symbol = pyxb.binding.content.ElementUse(MD_ServiceIdentification_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'pointOfContact')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 28, 5))
    st_5 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_5)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_4, False))
    symbol = pyxb.binding.content.ElementUse(MD_ServiceIdentification_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'resourceMaintenance')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 29, 5))
    st_6 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_6)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_5, False))
    symbol = pyxb.binding.content.ElementUse(MD_ServiceIdentification_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'graphicOverview')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 30, 5))
    st_7 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_7)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_6, False))
    symbol = pyxb.binding.content.ElementUse(MD_ServiceIdentification_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'resourceFormat')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 31, 5))
    st_8 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_8)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_7, False))
    symbol = pyxb.binding.content.ElementUse(MD_ServiceIdentification_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'descriptiveKeywords')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 32, 5))
    st_9 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_9)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_8, False))
    symbol = pyxb.binding.content.ElementUse(MD_ServiceIdentification_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'resourceSpecificUsage')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 33, 5))
    st_10 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_10)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_9, False))
    symbol = pyxb.binding.content.ElementUse(MD_ServiceIdentification_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'resourceConstraints')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 34, 5))
    st_11 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_11)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_10, False))
    symbol = pyxb.binding.content.ElementUse(MD_ServiceIdentification_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'aggregationInfo')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 35, 5))
    st_12 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_12)
    transitions = []
    transitions.append(fac.Transition(st_1, [
         ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_2, [
         ]))
    transitions.append(fac.Transition(st_3, [
         ]))
    transitions.append(fac.Transition(st_4, [
         ]))
    transitions.append(fac.Transition(st_5, [
         ]))
    transitions.append(fac.Transition(st_6, [
         ]))
    transitions.append(fac.Transition(st_7, [
         ]))
    transitions.append(fac.Transition(st_8, [
         ]))
    transitions.append(fac.Transition(st_9, [
         ]))
    transitions.append(fac.Transition(st_10, [
         ]))
    transitions.append(fac.Transition(st_11, [
         ]))
    transitions.append(fac.Transition(st_12, [
         ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_8, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_9, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_10, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_11, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_12, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_2._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_1, True) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_8, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_9, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_10, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_11, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_12, [
        fac.UpdateInstruction(cc_1, False) ]))
    st_3._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_2, True) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_8, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_9, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_10, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_11, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_12, [
        fac.UpdateInstruction(cc_2, False) ]))
    st_4._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_3, True) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_8, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_9, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_10, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_11, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_12, [
        fac.UpdateInstruction(cc_3, False) ]))
    st_5._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_4, True) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_4, False) ]))
    transitions.append(fac.Transition(st_8, [
        fac.UpdateInstruction(cc_4, False) ]))
    transitions.append(fac.Transition(st_9, [
        fac.UpdateInstruction(cc_4, False) ]))
    transitions.append(fac.Transition(st_10, [
        fac.UpdateInstruction(cc_4, False) ]))
    transitions.append(fac.Transition(st_11, [
        fac.UpdateInstruction(cc_4, False) ]))
    transitions.append(fac.Transition(st_12, [
        fac.UpdateInstruction(cc_4, False) ]))
    st_6._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_5, True) ]))
    transitions.append(fac.Transition(st_8, [
        fac.UpdateInstruction(cc_5, False) ]))
    transitions.append(fac.Transition(st_9, [
        fac.UpdateInstruction(cc_5, False) ]))
    transitions.append(fac.Transition(st_10, [
        fac.UpdateInstruction(cc_5, False) ]))
    transitions.append(fac.Transition(st_11, [
        fac.UpdateInstruction(cc_5, False) ]))
    transitions.append(fac.Transition(st_12, [
        fac.UpdateInstruction(cc_5, False) ]))
    st_7._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_8, [
        fac.UpdateInstruction(cc_6, True) ]))
    transitions.append(fac.Transition(st_9, [
        fac.UpdateInstruction(cc_6, False) ]))
    transitions.append(fac.Transition(st_10, [
        fac.UpdateInstruction(cc_6, False) ]))
    transitions.append(fac.Transition(st_11, [
        fac.UpdateInstruction(cc_6, False) ]))
    transitions.append(fac.Transition(st_12, [
        fac.UpdateInstruction(cc_6, False) ]))
    st_8._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_9, [
        fac.UpdateInstruction(cc_7, True) ]))
    transitions.append(fac.Transition(st_10, [
        fac.UpdateInstruction(cc_7, False) ]))
    transitions.append(fac.Transition(st_11, [
        fac.UpdateInstruction(cc_7, False) ]))
    transitions.append(fac.Transition(st_12, [
        fac.UpdateInstruction(cc_7, False) ]))
    st_9._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_10, [
        fac.UpdateInstruction(cc_8, True) ]))
    transitions.append(fac.Transition(st_11, [
        fac.UpdateInstruction(cc_8, False) ]))
    transitions.append(fac.Transition(st_12, [
        fac.UpdateInstruction(cc_8, False) ]))
    st_10._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_11, [
        fac.UpdateInstruction(cc_9, True) ]))
    transitions.append(fac.Transition(st_12, [
        fac.UpdateInstruction(cc_9, False) ]))
    st_11._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_12, [
        fac.UpdateInstruction(cc_10, True) ]))
    st_12._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
MD_ServiceIdentification_Type._Automaton = _BuildAutomaton_257()




MD_ServiceIdentification_PropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_ServiceIdentification'), MD_ServiceIdentification_Type, scope=MD_ServiceIdentification_PropertyType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 112, 1)))

def _BuildAutomaton_258 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_258
    del _BuildAutomaton_258
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 115, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(MD_ServiceIdentification_PropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_ServiceIdentification')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 116, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
MD_ServiceIdentification_PropertyType._Automaton = _BuildAutomaton_258()




MD_RepresentativeFraction_PropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_RepresentativeFraction'), MD_RepresentativeFraction_Type, scope=MD_RepresentativeFraction_PropertyType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 132, 1)))

def _BuildAutomaton_259 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_259
    del _BuildAutomaton_259
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 135, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(MD_RepresentativeFraction_PropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_RepresentativeFraction')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 136, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
MD_RepresentativeFraction_PropertyType._Automaton = _BuildAutomaton_259()




MD_Usage_PropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_Usage'), MD_Usage_Type, scope=MD_Usage_PropertyType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 158, 1)))

def _BuildAutomaton_260 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_260
    del _BuildAutomaton_260
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 161, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(MD_Usage_PropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_Usage')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 162, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
MD_Usage_PropertyType._Automaton = _BuildAutomaton_260()




MD_Keywords_PropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_Keywords'), MD_Keywords_Type, scope=MD_Keywords_PropertyType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 183, 1)))

def _BuildAutomaton_261 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_261
    del _BuildAutomaton_261
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 186, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(MD_Keywords_PropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_Keywords')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 187, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
MD_Keywords_PropertyType._Automaton = _BuildAutomaton_261()




DS_Association_PropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'DS_Association'), DS_Association_Type, scope=DS_Association_PropertyType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 201, 1)))

def _BuildAutomaton_262 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_262
    del _BuildAutomaton_262
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 204, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(DS_Association_PropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'DS_Association')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 205, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
DS_Association_PropertyType._Automaton = _BuildAutomaton_262()




MD_AggregateInformation_PropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_AggregateInformation'), MD_AggregateInformation_Type, scope=MD_AggregateInformation_PropertyType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 227, 1)))

def _BuildAutomaton_263 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_263
    del _BuildAutomaton_263
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 230, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(MD_AggregateInformation_PropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_AggregateInformation')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 231, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
MD_AggregateInformation_PropertyType._Automaton = _BuildAutomaton_263()




MD_Resolution_PropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_Resolution'), MD_Resolution_Type, scope=MD_Resolution_PropertyType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 244, 1)))

def _BuildAutomaton_264 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_264
    del _BuildAutomaton_264
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 247, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(MD_Resolution_PropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_Resolution')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 248, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
MD_Resolution_PropertyType._Automaton = _BuildAutomaton_264()




MD_TopicCategoryCode_PropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_TopicCategoryCode'), MD_TopicCategoryCode_Type, scope=MD_TopicCategoryCode_PropertyType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 280, 1)))

def _BuildAutomaton_265 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_265
    del _BuildAutomaton_265
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 283, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(MD_TopicCategoryCode_PropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_TopicCategoryCode')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 284, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
MD_TopicCategoryCode_PropertyType._Automaton = _BuildAutomaton_265()




MD_CharacterSetCode_PropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_CharacterSetCode'), CodeListValue_Type, scope=MD_CharacterSetCode_PropertyType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 290, 1)))

def _BuildAutomaton_266 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_266
    del _BuildAutomaton_266
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 293, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(MD_CharacterSetCode_PropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_CharacterSetCode')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 294, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
MD_CharacterSetCode_PropertyType._Automaton = _BuildAutomaton_266()




MD_SpatialRepresentationTypeCode_PropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_SpatialRepresentationTypeCode'), CodeListValue_Type, scope=MD_SpatialRepresentationTypeCode_PropertyType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 300, 1)))

def _BuildAutomaton_267 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_267
    del _BuildAutomaton_267
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 303, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(MD_SpatialRepresentationTypeCode_PropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_SpatialRepresentationTypeCode')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 304, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
MD_SpatialRepresentationTypeCode_PropertyType._Automaton = _BuildAutomaton_267()




MD_ProgressCode_PropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_ProgressCode'), CodeListValue_Type, scope=MD_ProgressCode_PropertyType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 310, 1)))

def _BuildAutomaton_268 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_268
    del _BuildAutomaton_268
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 313, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(MD_ProgressCode_PropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_ProgressCode')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 314, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
MD_ProgressCode_PropertyType._Automaton = _BuildAutomaton_268()




MD_KeywordTypeCode_PropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_KeywordTypeCode'), CodeListValue_Type, scope=MD_KeywordTypeCode_PropertyType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 320, 1)))

def _BuildAutomaton_269 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_269
    del _BuildAutomaton_269
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 323, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(MD_KeywordTypeCode_PropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_KeywordTypeCode')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 324, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
MD_KeywordTypeCode_PropertyType._Automaton = _BuildAutomaton_269()




DS_AssociationTypeCode_PropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'DS_AssociationTypeCode'), CodeListValue_Type, scope=DS_AssociationTypeCode_PropertyType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 330, 1)))

def _BuildAutomaton_270 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_270
    del _BuildAutomaton_270
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 333, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(DS_AssociationTypeCode_PropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'DS_AssociationTypeCode')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 334, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
DS_AssociationTypeCode_PropertyType._Automaton = _BuildAutomaton_270()




DS_InitiativeTypeCode_PropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'DS_InitiativeTypeCode'), CodeListValue_Type, scope=DS_InitiativeTypeCode_PropertyType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 340, 1)))

def _BuildAutomaton_271 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_271
    del _BuildAutomaton_271
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 343, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(DS_InitiativeTypeCode_PropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'DS_InitiativeTypeCode')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/identification.xsd', 344, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
DS_InitiativeTypeCode_PropertyType._Automaton = _BuildAutomaton_271()




MD_MaintenanceInformation_PropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_MaintenanceInformation'), MD_MaintenanceInformation_Type, scope=MD_MaintenanceInformation_PropertyType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/maintenance.xsd', 34, 1)))

def _BuildAutomaton_272 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_272
    del _BuildAutomaton_272
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/maintenance.xsd', 37, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(MD_MaintenanceInformation_PropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_MaintenanceInformation')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/maintenance.xsd', 38, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
MD_MaintenanceInformation_PropertyType._Automaton = _BuildAutomaton_272()




MD_ScopeDescription_PropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_ScopeDescription'), MD_ScopeDescription_Type, scope=MD_ScopeDescription_PropertyType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/maintenance.xsd', 58, 1)))

def _BuildAutomaton_273 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_273
    del _BuildAutomaton_273
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/maintenance.xsd', 61, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(MD_ScopeDescription_PropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_ScopeDescription')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/maintenance.xsd', 62, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
MD_ScopeDescription_PropertyType._Automaton = _BuildAutomaton_273()




MD_MaintenanceFrequencyCode_PropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_MaintenanceFrequencyCode'), CodeListValue_Type, scope=MD_MaintenanceFrequencyCode_PropertyType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/maintenance.xsd', 68, 1)))

def _BuildAutomaton_274 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_274
    del _BuildAutomaton_274
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/maintenance.xsd', 71, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(MD_MaintenanceFrequencyCode_PropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_MaintenanceFrequencyCode')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/maintenance.xsd', 72, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
MD_MaintenanceFrequencyCode_PropertyType._Automaton = _BuildAutomaton_274()




MD_ScopeCode_PropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_ScopeCode'), CodeListValue_Type, scope=MD_ScopeCode_PropertyType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/maintenance.xsd', 78, 1)))

def _BuildAutomaton_275 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_275
    del _BuildAutomaton_275
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/maintenance.xsd', 81, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(MD_ScopeCode_PropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_ScopeCode')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/maintenance.xsd', 82, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
MD_ScopeCode_PropertyType._Automaton = _BuildAutomaton_275()




DS_Aggregate_PropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'AbstractDS_Aggregate'), AbstractDS_Aggregate_Type, abstract=pyxb.binding.datatypes.boolean(1), scope=DS_Aggregate_PropertyType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataApplication.xsd', 30, 1)))

def _BuildAutomaton_276 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_276
    del _BuildAutomaton_276
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataApplication.xsd', 33, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(DS_Aggregate_PropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'AbstractDS_Aggregate')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataApplication.xsd', 34, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
DS_Aggregate_PropertyType._Automaton = _BuildAutomaton_276()




DS_DataSet_PropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'DS_DataSet'), DS_DataSet_Type, scope=DS_DataSet_PropertyType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataApplication.xsd', 54, 1)))

def _BuildAutomaton_277 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_277
    del _BuildAutomaton_277
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataApplication.xsd', 57, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(DS_DataSet_PropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'DS_DataSet')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataApplication.xsd', 58, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
DS_DataSet_PropertyType._Automaton = _BuildAutomaton_277()




def _BuildAutomaton_278 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_278
    del _BuildAutomaton_278
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataApplication.xsd', 23, 5))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataApplication.xsd', 24, 5))
    counters.add(cc_1)
    states = []
    final_update = None
    symbol = pyxb.binding.content.ElementUse(DS_OtherAggregate_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'composedOf')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataApplication.xsd', 21, 5))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(DS_OtherAggregate_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'seriesMetadata')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataApplication.xsd', 22, 5))
    st_1 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(DS_OtherAggregate_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'subset')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataApplication.xsd', 23, 5))
    st_2 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_1, False))
    symbol = pyxb.binding.content.ElementUse(DS_OtherAggregate_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'superset')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataApplication.xsd', 24, 5))
    st_3 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_3)
    transitions = []
    transitions.append(fac.Transition(st_0, [
         ]))
    transitions.append(fac.Transition(st_1, [
         ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_1, [
         ]))
    transitions.append(fac.Transition(st_2, [
         ]))
    transitions.append(fac.Transition(st_3, [
         ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_2._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_1, True) ]))
    st_3._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
DS_OtherAggregate_Type._Automaton = _BuildAutomaton_278()




DS_OtherAggregate_PropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'DS_OtherAggregate'), DS_OtherAggregate_Type, scope=DS_OtherAggregate_PropertyType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataApplication.xsd', 70, 1)))

def _BuildAutomaton_279 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_279
    del _BuildAutomaton_279
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataApplication.xsd', 73, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(DS_OtherAggregate_PropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'DS_OtherAggregate')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataApplication.xsd', 74, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
DS_OtherAggregate_PropertyType._Automaton = _BuildAutomaton_279()




def _BuildAutomaton_280 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_280
    del _BuildAutomaton_280
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataApplication.xsd', 23, 5))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataApplication.xsd', 24, 5))
    counters.add(cc_1)
    states = []
    final_update = None
    symbol = pyxb.binding.content.ElementUse(DS_Series_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'composedOf')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataApplication.xsd', 21, 5))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(DS_Series_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'seriesMetadata')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataApplication.xsd', 22, 5))
    st_1 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(DS_Series_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'subset')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataApplication.xsd', 23, 5))
    st_2 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_1, False))
    symbol = pyxb.binding.content.ElementUse(DS_Series_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'superset')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataApplication.xsd', 24, 5))
    st_3 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_3)
    transitions = []
    transitions.append(fac.Transition(st_0, [
         ]))
    transitions.append(fac.Transition(st_1, [
         ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_1, [
         ]))
    transitions.append(fac.Transition(st_2, [
         ]))
    transitions.append(fac.Transition(st_3, [
         ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_2._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_1, True) ]))
    st_3._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
DS_Series_Type._Automaton = _BuildAutomaton_280()




DS_Series_PropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'DS_Series'), DS_Series_Type, scope=DS_Series_PropertyType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataApplication.xsd', 86, 1)))

def _BuildAutomaton_281 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_281
    del _BuildAutomaton_281
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataApplication.xsd', 89, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(DS_Series_PropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'DS_Series')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataApplication.xsd', 90, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
DS_Series_PropertyType._Automaton = _BuildAutomaton_281()




def _BuildAutomaton_282 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_282
    del _BuildAutomaton_282
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataApplication.xsd', 23, 5))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataApplication.xsd', 24, 5))
    counters.add(cc_1)
    states = []
    final_update = None
    symbol = pyxb.binding.content.ElementUse(DS_Initiative_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'composedOf')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataApplication.xsd', 21, 5))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(DS_Initiative_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'seriesMetadata')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataApplication.xsd', 22, 5))
    st_1 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(DS_Initiative_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'subset')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataApplication.xsd', 23, 5))
    st_2 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_1, False))
    symbol = pyxb.binding.content.ElementUse(DS_Initiative_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'superset')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataApplication.xsd', 24, 5))
    st_3 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_3)
    transitions = []
    transitions.append(fac.Transition(st_0, [
         ]))
    transitions.append(fac.Transition(st_1, [
         ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_1, [
         ]))
    transitions.append(fac.Transition(st_2, [
         ]))
    transitions.append(fac.Transition(st_3, [
         ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_2._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_1, True) ]))
    st_3._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
DS_Initiative_Type._Automaton = _BuildAutomaton_282()




DS_Initiative_PropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'DS_Initiative'), DS_Initiative_Type, scope=DS_Initiative_PropertyType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataApplication.xsd', 102, 1)))

def _BuildAutomaton_283 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_283
    del _BuildAutomaton_283
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataApplication.xsd', 105, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(DS_Initiative_PropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'DS_Initiative')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataApplication.xsd', 106, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
DS_Initiative_PropertyType._Automaton = _BuildAutomaton_283()




DS_Platform_PropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'DS_Platform'), DS_Platform_Type, scope=DS_Platform_PropertyType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataApplication.xsd', 118, 1)))

def _BuildAutomaton_284 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_284
    del _BuildAutomaton_284
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataApplication.xsd', 121, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(DS_Platform_PropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'DS_Platform')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataApplication.xsd', 122, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
DS_Platform_PropertyType._Automaton = _BuildAutomaton_284()




DS_Sensor_PropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'DS_Sensor'), DS_Sensor_Type, scope=DS_Sensor_PropertyType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataApplication.xsd', 134, 1)))

def _BuildAutomaton_285 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_285
    del _BuildAutomaton_285
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataApplication.xsd', 137, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(DS_Sensor_PropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'DS_Sensor')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataApplication.xsd', 138, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
DS_Sensor_PropertyType._Automaton = _BuildAutomaton_285()




DS_ProductionSeries_PropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'DS_ProductionSeries'), DS_ProductionSeries_Type, scope=DS_ProductionSeries_PropertyType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataApplication.xsd', 150, 1)))

def _BuildAutomaton_286 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_286
    del _BuildAutomaton_286
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataApplication.xsd', 153, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(DS_ProductionSeries_PropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'DS_ProductionSeries')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataApplication.xsd', 154, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
DS_ProductionSeries_PropertyType._Automaton = _BuildAutomaton_286()




DS_StereoMate_PropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'DS_StereoMate'), DS_StereoMate_Type, scope=DS_StereoMate_PropertyType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataApplication.xsd', 166, 1)))

def _BuildAutomaton_287 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_287
    del _BuildAutomaton_287
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataApplication.xsd', 169, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(DS_StereoMate_PropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'DS_StereoMate')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataApplication.xsd', 170, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
DS_StereoMate_PropertyType._Automaton = _BuildAutomaton_287()




MD_Metadata_PropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_Metadata'), MD_Metadata_Type, scope=MD_Metadata_PropertyType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataEntity.xsd', 61, 1)))

def _BuildAutomaton_288 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_288
    del _BuildAutomaton_288
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataEntity.xsd', 64, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(MD_Metadata_PropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_Metadata')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataEntity.xsd', 65, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
MD_Metadata_PropertyType._Automaton = _BuildAutomaton_288()




MD_ExtendedElementInformation_PropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_ExtendedElementInformation'), MD_ExtendedElementInformation_Type, scope=MD_ExtendedElementInformation_PropertyType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataExtension.xsd', 39, 1)))

def _BuildAutomaton_289 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_289
    del _BuildAutomaton_289
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataExtension.xsd', 42, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(MD_ExtendedElementInformation_PropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_ExtendedElementInformation')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataExtension.xsd', 43, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
MD_ExtendedElementInformation_PropertyType._Automaton = _BuildAutomaton_289()




MD_MetadataExtensionInformation_PropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_MetadataExtensionInformation'), MD_MetadataExtensionInformation_Type, scope=MD_MetadataExtensionInformation_PropertyType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataExtension.xsd', 63, 1)))

def _BuildAutomaton_290 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_290
    del _BuildAutomaton_290
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataExtension.xsd', 66, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(MD_MetadataExtensionInformation_PropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_MetadataExtensionInformation')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataExtension.xsd', 67, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
MD_MetadataExtensionInformation_PropertyType._Automaton = _BuildAutomaton_290()




MD_ObligationCode_PropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_ObligationCode'), MD_ObligationCode_Type, scope=MD_ObligationCode_PropertyType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataExtension.xsd', 81, 1)))

def _BuildAutomaton_291 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_291
    del _BuildAutomaton_291
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataExtension.xsd', 84, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(MD_ObligationCode_PropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_ObligationCode')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataExtension.xsd', 85, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
MD_ObligationCode_PropertyType._Automaton = _BuildAutomaton_291()




MD_DatatypeCode_PropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_DatatypeCode'), CodeListValue_Type, scope=MD_DatatypeCode_PropertyType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataExtension.xsd', 91, 1)))

def _BuildAutomaton_292 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_292
    del _BuildAutomaton_292
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataExtension.xsd', 94, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(MD_DatatypeCode_PropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_DatatypeCode')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataExtension.xsd', 95, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
MD_DatatypeCode_PropertyType._Automaton = _BuildAutomaton_292()




MD_PortrayalCatalogueReference_PropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_PortrayalCatalogueReference'), MD_PortrayalCatalogueReference_Type, scope=MD_PortrayalCatalogueReference_PropertyType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/portrayalCatalogue.xsd', 27, 1)))

def _BuildAutomaton_293 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_293
    del _BuildAutomaton_293
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/portrayalCatalogue.xsd', 30, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(MD_PortrayalCatalogueReference_PropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_PortrayalCatalogueReference')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/portrayalCatalogue.xsd', 31, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
MD_PortrayalCatalogueReference_PropertyType._Automaton = _BuildAutomaton_293()




RS_Identifier_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'codeSpace'), CharacterString_PropertyType, scope=RS_Identifier_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/referenceSystem.xsd', 19, 5)))

RS_Identifier_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'version'), CharacterString_PropertyType, scope=RS_Identifier_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/referenceSystem.xsd', 20, 5)))

def _BuildAutomaton_294 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_294
    del _BuildAutomaton_294
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/referenceSystem.xsd', 60, 5))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/referenceSystem.xsd', 19, 5))
    counters.add(cc_1)
    cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/referenceSystem.xsd', 20, 5))
    counters.add(cc_2)
    states = []
    final_update = None
    symbol = pyxb.binding.content.ElementUse(RS_Identifier_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'authority')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/referenceSystem.xsd', 60, 5))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(RS_Identifier_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'code')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/referenceSystem.xsd', 61, 5))
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_1, False))
    symbol = pyxb.binding.content.ElementUse(RS_Identifier_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'codeSpace')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/referenceSystem.xsd', 19, 5))
    st_2 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_2, False))
    symbol = pyxb.binding.content.ElementUse(RS_Identifier_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'version')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/referenceSystem.xsd', 20, 5))
    st_3 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_3)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_2, [
         ]))
    transitions.append(fac.Transition(st_3, [
         ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_1, True) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_1, False) ]))
    st_2._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_2, True) ]))
    st_3._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
RS_Identifier_Type._Automaton = _BuildAutomaton_294()




RS_Identifier_PropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'RS_Identifier'), RS_Identifier_Type, scope=RS_Identifier_PropertyType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/referenceSystem.xsd', 26, 1)))

def _BuildAutomaton_295 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_295
    del _BuildAutomaton_295
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/referenceSystem.xsd', 29, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(RS_Identifier_PropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'RS_Identifier')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/referenceSystem.xsd', 30, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
RS_Identifier_PropertyType._Automaton = _BuildAutomaton_295()




MD_ReferenceSystem_PropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_ReferenceSystem'), MD_ReferenceSystem_Type, scope=MD_ReferenceSystem_PropertyType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/referenceSystem.xsd', 46, 1)))

def _BuildAutomaton_296 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_296
    del _BuildAutomaton_296
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/referenceSystem.xsd', 49, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(MD_ReferenceSystem_PropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_ReferenceSystem')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/referenceSystem.xsd', 50, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
MD_ReferenceSystem_PropertyType._Automaton = _BuildAutomaton_296()




MD_Identifier_PropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_Identifier'), MD_Identifier_Type, scope=MD_Identifier_PropertyType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/referenceSystem.xsd', 67, 1)))

def _BuildAutomaton_297 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_297
    del _BuildAutomaton_297
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/referenceSystem.xsd', 70, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(MD_Identifier_PropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_Identifier')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/referenceSystem.xsd', 71, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
MD_Identifier_PropertyType._Automaton = _BuildAutomaton_297()




RS_ReferenceSystem_PropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'AbstractRS_ReferenceSystem'), AbstractRS_ReferenceSystem_Type, abstract=pyxb.binding.datatypes.boolean(1), scope=RS_ReferenceSystem_PropertyType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/referenceSystem.xsd', 91, 1)))

def _BuildAutomaton_298 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_298
    del _BuildAutomaton_298
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/referenceSystem.xsd', 94, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(RS_ReferenceSystem_PropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'AbstractRS_ReferenceSystem')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/referenceSystem.xsd', 95, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
RS_ReferenceSystem_PropertyType._Automaton = _BuildAutomaton_298()




MD_GridSpatialRepresentation_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'numberOfDimensions'), Integer_PropertyType, scope=MD_GridSpatialRepresentation_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/spatialRepresentation.xsd', 22, 5)))

MD_GridSpatialRepresentation_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'axisDimensionProperties'), MD_Dimension_PropertyType, scope=MD_GridSpatialRepresentation_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/spatialRepresentation.xsd', 23, 5)))

MD_GridSpatialRepresentation_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'cellGeometry'), MD_CellGeometryCode_PropertyType, scope=MD_GridSpatialRepresentation_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/spatialRepresentation.xsd', 24, 5)))

MD_GridSpatialRepresentation_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'transformationParameterAvailability'), Boolean_PropertyType, scope=MD_GridSpatialRepresentation_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/spatialRepresentation.xsd', 25, 5)))

def _BuildAutomaton_299 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_299
    del _BuildAutomaton_299
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/spatialRepresentation.xsd', 23, 5))
    counters.add(cc_0)
    states = []
    final_update = None
    symbol = pyxb.binding.content.ElementUse(MD_GridSpatialRepresentation_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'numberOfDimensions')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/spatialRepresentation.xsd', 22, 5))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(MD_GridSpatialRepresentation_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'axisDimensionProperties')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/spatialRepresentation.xsd', 23, 5))
    st_1 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(MD_GridSpatialRepresentation_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'cellGeometry')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/spatialRepresentation.xsd', 24, 5))
    st_2 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(MD_GridSpatialRepresentation_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'transformationParameterAvailability')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/spatialRepresentation.xsd', 25, 5))
    st_3 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_3)
    transitions = []
    transitions.append(fac.Transition(st_1, [
         ]))
    transitions.append(fac.Transition(st_2, [
         ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_3, [
         ]))
    st_2._set_transitionSet(transitions)
    transitions = []
    st_3._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
MD_GridSpatialRepresentation_Type._Automaton = _BuildAutomaton_299()




MD_GridSpatialRepresentation_PropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_GridSpatialRepresentation'), MD_GridSpatialRepresentation_Type, scope=MD_GridSpatialRepresentation_PropertyType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/spatialRepresentation.xsd', 31, 1)))

def _BuildAutomaton_300 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_300
    del _BuildAutomaton_300
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/spatialRepresentation.xsd', 34, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(MD_GridSpatialRepresentation_PropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_GridSpatialRepresentation')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/spatialRepresentation.xsd', 35, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
MD_GridSpatialRepresentation_PropertyType._Automaton = _BuildAutomaton_300()




MD_VectorSpatialRepresentation_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'topologyLevel'), MD_TopologyLevelCode_PropertyType, scope=MD_VectorSpatialRepresentation_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/spatialRepresentation.xsd', 48, 5)))

MD_VectorSpatialRepresentation_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'geometricObjects'), MD_GeometricObjects_PropertyType, scope=MD_VectorSpatialRepresentation_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/spatialRepresentation.xsd', 49, 5)))

def _BuildAutomaton_301 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_301
    del _BuildAutomaton_301
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/spatialRepresentation.xsd', 48, 5))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/spatialRepresentation.xsd', 49, 5))
    counters.add(cc_1)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(MD_VectorSpatialRepresentation_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'topologyLevel')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/spatialRepresentation.xsd', 48, 5))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_1, False))
    symbol = pyxb.binding.content.ElementUse(MD_VectorSpatialRepresentation_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'geometricObjects')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/spatialRepresentation.xsd', 49, 5))
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_1, True) ]))
    st_1._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
MD_VectorSpatialRepresentation_Type._Automaton = _BuildAutomaton_301()




MD_VectorSpatialRepresentation_PropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_VectorSpatialRepresentation'), MD_VectorSpatialRepresentation_Type, scope=MD_VectorSpatialRepresentation_PropertyType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/spatialRepresentation.xsd', 55, 1)))

def _BuildAutomaton_302 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_302
    del _BuildAutomaton_302
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/spatialRepresentation.xsd', 58, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(MD_VectorSpatialRepresentation_PropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_VectorSpatialRepresentation')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/spatialRepresentation.xsd', 59, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
MD_VectorSpatialRepresentation_PropertyType._Automaton = _BuildAutomaton_302()




MD_SpatialRepresentation_PropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'AbstractMD_SpatialRepresentation'), AbstractMD_SpatialRepresentation_Type, abstract=pyxb.binding.datatypes.boolean(1), scope=MD_SpatialRepresentation_PropertyType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/spatialRepresentation.xsd', 76, 1)))

def _BuildAutomaton_303 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_303
    del _BuildAutomaton_303
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/spatialRepresentation.xsd', 79, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(MD_SpatialRepresentation_PropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'AbstractMD_SpatialRepresentation')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/spatialRepresentation.xsd', 80, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
MD_SpatialRepresentation_PropertyType._Automaton = _BuildAutomaton_303()




MD_Georeferenceable_PropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_Georeferenceable'), MD_Georeferenceable_Type, scope=MD_Georeferenceable_PropertyType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/spatialRepresentation.xsd', 100, 1)))

def _BuildAutomaton_304 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_304
    del _BuildAutomaton_304
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/spatialRepresentation.xsd', 103, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(MD_Georeferenceable_PropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_Georeferenceable')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/spatialRepresentation.xsd', 104, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
MD_Georeferenceable_PropertyType._Automaton = _BuildAutomaton_304()




MD_Dimension_PropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_Dimension'), MD_Dimension_Type, scope=MD_Dimension_PropertyType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/spatialRepresentation.xsd', 122, 1)))

def _BuildAutomaton_305 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_305
    del _BuildAutomaton_305
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/spatialRepresentation.xsd', 125, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(MD_Dimension_PropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_Dimension')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/spatialRepresentation.xsd', 126, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
MD_Dimension_PropertyType._Automaton = _BuildAutomaton_305()




MD_Georectified_PropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_Georectified'), MD_Georectified_Type, scope=MD_Georectified_PropertyType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/spatialRepresentation.xsd', 148, 1)))

def _BuildAutomaton_306 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_306
    del _BuildAutomaton_306
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/spatialRepresentation.xsd', 151, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(MD_Georectified_PropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_Georectified')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/spatialRepresentation.xsd', 152, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
MD_Georectified_PropertyType._Automaton = _BuildAutomaton_306()




MD_GeometricObjects_PropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_GeometricObjects'), MD_GeometricObjects_Type, scope=MD_GeometricObjects_PropertyType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/spatialRepresentation.xsd', 169, 1)))

def _BuildAutomaton_307 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_307
    del _BuildAutomaton_307
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/spatialRepresentation.xsd', 172, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(MD_GeometricObjects_PropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_GeometricObjects')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/spatialRepresentation.xsd', 173, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
MD_GeometricObjects_PropertyType._Automaton = _BuildAutomaton_307()




MD_PixelOrientationCode_PropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_PixelOrientationCode'), MD_PixelOrientationCode_Type, scope=MD_PixelOrientationCode_PropertyType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/spatialRepresentation.xsd', 189, 1)))

def _BuildAutomaton_308 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_308
    del _BuildAutomaton_308
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/spatialRepresentation.xsd', 192, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(MD_PixelOrientationCode_PropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_PixelOrientationCode')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/spatialRepresentation.xsd', 193, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
MD_PixelOrientationCode_PropertyType._Automaton = _BuildAutomaton_308()




MD_TopologyLevelCode_PropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_TopologyLevelCode'), CodeListValue_Type, scope=MD_TopologyLevelCode_PropertyType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/spatialRepresentation.xsd', 199, 1)))

def _BuildAutomaton_309 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_309
    del _BuildAutomaton_309
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/spatialRepresentation.xsd', 202, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(MD_TopologyLevelCode_PropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_TopologyLevelCode')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/spatialRepresentation.xsd', 203, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
MD_TopologyLevelCode_PropertyType._Automaton = _BuildAutomaton_309()




MD_GeometricObjectTypeCode_PropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_GeometricObjectTypeCode'), CodeListValue_Type, scope=MD_GeometricObjectTypeCode_PropertyType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/spatialRepresentation.xsd', 209, 1)))

def _BuildAutomaton_310 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_310
    del _BuildAutomaton_310
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/spatialRepresentation.xsd', 212, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(MD_GeometricObjectTypeCode_PropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_GeometricObjectTypeCode')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/spatialRepresentation.xsd', 213, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
MD_GeometricObjectTypeCode_PropertyType._Automaton = _BuildAutomaton_310()




MD_CellGeometryCode_PropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_CellGeometryCode'), CodeListValue_Type, scope=MD_CellGeometryCode_PropertyType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/spatialRepresentation.xsd', 219, 1)))

def _BuildAutomaton_311 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_311
    del _BuildAutomaton_311
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/spatialRepresentation.xsd', 222, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(MD_CellGeometryCode_PropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_CellGeometryCode')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/spatialRepresentation.xsd', 223, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
MD_CellGeometryCode_PropertyType._Automaton = _BuildAutomaton_311()




MD_DimensionNameTypeCode_PropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_DimensionNameTypeCode'), CodeListValue_Type, scope=MD_DimensionNameTypeCode_PropertyType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/spatialRepresentation.xsd', 229, 1)))

def _BuildAutomaton_312 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_312
    del _BuildAutomaton_312
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/spatialRepresentation.xsd', 232, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(MD_DimensionNameTypeCode_PropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'MD_DimensionNameTypeCode')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/spatialRepresentation.xsd', 233, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
MD_DimensionNameTypeCode_PropertyType._Automaton = _BuildAutomaton_312()




SC_CRS_PropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractCRS'), AbstractCRSType, abstract=pyxb.binding.datatypes.boolean(1), scope=SC_CRS_PropertyType, documentation='gml:AbstractCRS specifies a coordinate reference system which is usually single but may be compound. This abstract complex type shall not be used, extended, or restricted, in a GML Application Schema, to define a concrete subtype with a meaning equivalent to a concrete subtype specified in this document.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/referenceSystems.xsd', 30, 1)))

def _BuildAutomaton_313 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_313
    del _BuildAutomaton_313
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gsr/spatialReferencing.xsd', 18, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(SC_CRS_PropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractCRS')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gsr/spatialReferencing.xsd', 19, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
SC_CRS_PropertyType._Automaton = _BuildAutomaton_313()




GM_Point_PropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'Point'), PointType, scope=GM_Point_PropertyType, documentation='A Point is defined by a single coordinate tuple. The direct position of a point is specified by the pos element which is of type DirectPositionType.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic0d1d.xsd', 189, 1)))

def _BuildAutomaton_314 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_314
    del _BuildAutomaton_314
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gss/geometry.xsd', 18, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(GM_Point_PropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'Point')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gss/geometry.xsd', 19, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
GM_Point_PropertyType._Automaton = _BuildAutomaton_314()




GM_Object_PropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractGeometry'), AbstractGeometryType, abstract=pyxb.binding.datatypes.boolean(1), scope=GM_Object_PropertyType, documentation='The AbstractGeometry element is the abstract head of the substitution group for all geometry elements of GML. This includes pre-defined and user-defined geometry elements. Any geometry element shall be a direct or indirect extension/restriction of AbstractGeometryType and shall be directly or indirectly in the substitution group of AbstractGeometry.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic0d1d.xsd', 50, 1)))

def _BuildAutomaton_315 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_315
    del _BuildAutomaton_315
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gss/geometry.xsd', 29, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(GM_Object_PropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractGeometry')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gss/geometry.xsd', 30, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
GM_Object_PropertyType._Automaton = _BuildAutomaton_315()




TM_Primitive_PropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractTimePrimitive'), AbstractTimePrimitiveType, abstract=pyxb.binding.datatypes.boolean(1), scope=TM_Primitive_PropertyType, documentation='gml:AbstractTimePrimitive acts as the head of a substitution group for geometric and topological temporal primitives.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporal.xsd', 28, 1)))

def _BuildAutomaton_316 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_316
    del _BuildAutomaton_316
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gts/temporalObjects.xsd', 18, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(TM_Primitive_PropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractTimePrimitive')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gts/temporalObjects.xsd', 19, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
TM_Primitive_PropertyType._Automaton = _BuildAutomaton_316()




TM_PeriodDuration_PropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gts, 'TM_PeriodDuration'), pyxb.binding.datatypes.duration, scope=TM_PeriodDuration_PropertyType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gts/temporalObjects.xsd', 26, 1)))

def _BuildAutomaton_317 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_317
    del _BuildAutomaton_317
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gts/temporalObjects.xsd', 29, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(TM_PeriodDuration_PropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gts, 'TM_PeriodDuration')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gts/temporalObjects.xsd', 30, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
TM_PeriodDuration_PropertyType._Automaton = _BuildAutomaton_317()




CTD_ANON_6._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'AbstractDQ_PositionalAccuracy'), AbstractDQ_PositionalAccuracy_Type, abstract=pyxb.binding.datatypes.boolean(1), scope=CTD_ANON_6, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 433, 1)))

def _BuildAutomaton_318 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_318
    del _BuildAutomaton_318
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 53, 3))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(CTD_ANON_6._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'AbstractDQ_PositionalAccuracy')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 54, 4))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
CTD_ANON_6._Automaton = _BuildAutomaton_318()




CoordinateOperationPropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractCoordinateOperation'), AbstractCoordinateOperationType, abstract=pyxb.binding.datatypes.boolean(1), scope=CoordinateOperationPropertyType, documentation='gml:AbstractCoordinateOperation is a mathematical operation on coordinates that transforms or converts coordinates to another coordinate reference system. Many but not all coordinate operations (from CRS A to CRS B) also uniquely define the inverse operation (from CRS B to CRS A). In some cases, the operation method algorithm for the inverse operation is the same as for the forward algorithm, but the signs of some operation parameter values shall be reversed. In other cases, different algorithms are required for the forward and inverse operations, but the same operation parameter values are used. If (some) entirely different parameter values are needed, a different coordinate operation shall be defined.\nThe optional coordinateOperationAccuracy property elements provide estimates of the impact of this coordinate operation on point position accuracy.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 23, 1)))

def _BuildAutomaton_319 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_319
    del _BuildAutomaton_319
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 73, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(CoordinateOperationPropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractCoordinateOperation')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 74, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
CoordinateOperationPropertyType._Automaton = _BuildAutomaton_319()




SingleOperationPropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractSingleOperation'), AbstractCoordinateOperationType, abstract=pyxb.binding.datatypes.boolean(1), scope=SingleOperationPropertyType, documentation='gml:AbstractSingleOperation is a single (not concatenated) coordinate operation.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 78, 1)))

def _BuildAutomaton_320 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_320
    del _BuildAutomaton_320
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 87, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(SingleOperationPropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractSingleOperation')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 88, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
SingleOperationPropertyType._Automaton = _BuildAutomaton_320()




GeneralConversionPropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractGeneralConversion'), AbstractGeneralConversionType, abstract=pyxb.binding.datatypes.boolean(1), scope=GeneralConversionPropertyType, documentation='gm:AbstractGeneralConversion is an abstract operation on coordinates that does not include any change of datum. The best-known example of a coordinate conversion is a map projection. The parameters describing coordinate conversions are defined rather than empirically derived. Note that some conversions have no parameters. The operationVersion, sourceCRS, and targetCRS elements are omitted in a coordinate conversion.\nThis abstract complex type is expected to be extended for well-known operation methods with many Conversion instances, in GML Application Schemas that define operation-method-specialized element names and contents. This conversion uses an operation method, usually with associated parameter values. However, operation methods and parameter values are directly associated with concrete subtypes, not with this abstract type. All concrete types derived from this type shall extend this type to include a "usesMethod" element that references the "OperationMethod" element. Similarly, all concrete types derived from this type shall extend this type to include zero or more elements each named "uses...Value" that each use the type of an element substitutable for the "AbstractGeneralParameterValue" element.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 92, 1)))

def _BuildAutomaton_321 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_321
    del _BuildAutomaton_321
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 120, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(GeneralConversionPropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractGeneralConversion')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 121, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
GeneralConversionPropertyType._Automaton = _BuildAutomaton_321()




GeneralTransformationPropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractGeneralTransformation'), AbstractGeneralTransformationType, abstract=pyxb.binding.datatypes.boolean(1), scope=GeneralTransformationPropertyType, documentation='gml:AbstractGeneralTransformation is an abstract operation on coordinates that usually includes a change of Datum. The parameters of a coordinate transformation are empirically derived from data containing the coordinates of a series of points in both coordinate reference systems. This computational process is usually "over-determined", allowing derivation of error (or accuracy) estimates for the transformation. Also, the stochastic nature of the parameters may result in multiple (different) versions of the same coordinate transformation. The operationVersion, sourceCRS, and targetCRS proeprty elements are mandatory in a coordinate transformation.\nThis abstract complex type is expected to be extended for well-known operation methods with many Transformation instances, in Application Schemas that define operation-method-specialized value element names and contents. This transformation uses an operation method with associated parameter values. However, operation methods and parameter values are directly associated with concrete subtypes, not with this abstract type. All concrete types derived from this type shall extend this type to include a "usesMethod" element that references one "OperationMethod" element. Similarly, all concrete types derived from this type shall extend this type to include one or more elements each named "uses...Value" that each use the type of an element substitutable for the "AbstractGeneralParameterValue" element.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 125, 1)))

def _BuildAutomaton_322 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_322
    del _BuildAutomaton_322
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 156, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(GeneralTransformationPropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractGeneralTransformation')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 157, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
GeneralTransformationPropertyType._Automaton = _BuildAutomaton_322()




ConcatenatedOperationPropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'ConcatenatedOperation'), ConcatenatedOperationType, scope=ConcatenatedOperationPropertyType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 161, 1)))

def _BuildAutomaton_323 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_323
    del _BuildAutomaton_323
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 185, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(ConcatenatedOperationPropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'ConcatenatedOperation')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 186, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
ConcatenatedOperationPropertyType._Automaton = _BuildAutomaton_323()




PassThroughOperationPropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'PassThroughOperation'), PassThroughOperationType, scope=PassThroughOperationPropertyType, documentation='gml:PassThroughOperation is a pass-through operation specifies that a subset of a coordinate tuple is subject to a specific coordinate operation.\nThe modifiedCoordinate property elements are an ordered sequence of positive integers defining the positions in a coordinate tuple of the coordinates affected by this pass-through operation. The AggregationAttributeGroup should be used to specify that the modifiedCoordinate elements are ordered.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 190, 1)))

def _BuildAutomaton_324 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_324
    del _BuildAutomaton_324
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 216, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(PassThroughOperationPropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'PassThroughOperation')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 217, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
PassThroughOperationPropertyType._Automaton = _BuildAutomaton_324()




ConversionPropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'Conversion'), ConversionType, scope=ConversionPropertyType, documentation='gml:Conversion is a concrete operation on coordinates that does not include any change of Datum. The best-known example of a coordinate conversion is a map projection. The parameters describing coordinate conversions are defined rather than empirically derived. Note that some conversions have no parameters.\nThis concrete complex type can be used without using a GML Application Schema that defines operation-method-specialized element names and contents, especially for methods with only one Conversion instance.\nThe usesValue property elements are an unordered list of composition associations to the set of parameter values used by this conversion operation.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 221, 1)))

def _BuildAutomaton_325 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_325
    del _BuildAutomaton_325
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 252, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(ConversionPropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'Conversion')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 253, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
ConversionPropertyType._Automaton = _BuildAutomaton_325()




TransformationPropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'Transformation'), TransformationType, scope=TransformationPropertyType, documentation='gml:Transformation is a concrete object element derived from gml:GeneralTransformation (13.6.2.13).\nThis concrete object can be used for all operation methods, without using a GML Application Schema that defines operation-method-specialized element names and contents, especially for methods with only one Transformation instance.\nThe parameterValue elements are an unordered list of composition associations to the set of parameter values used by this conversion operation.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 257, 1)))

def _BuildAutomaton_326 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_326
    del _BuildAutomaton_326
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 278, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(TransformationPropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'Transformation')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 279, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
TransformationPropertyType._Automaton = _BuildAutomaton_326()




CTD_ANON_7._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'CI_Citation'), CI_Citation_Type, scope=CTD_ANON_7, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/citation.xsd', 66, 1)))

def _BuildAutomaton_327 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_327
    del _BuildAutomaton_327
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 411, 3))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(CTD_ANON_7._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'CI_Citation')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 412, 4))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
CTD_ANON_7._Automaton = _BuildAutomaton_327()




OperationMethodPropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'OperationMethod'), OperationMethodType, scope=OperationMethodPropertyType, documentation='gml:OperationMethod is a method (algorithm or procedure) used to perform a coordinate operation. Most operation methods use a number of operation parameters, although some coordinate conversions use none. Each coordinate operation using the method assigns values to these parameters.\nThe parameter elements are an unordered list of associations to the set of operation parameters and parameter groups used by this operation method.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 385, 1)))

def _BuildAutomaton_328 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_328
    del _BuildAutomaton_328
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 441, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(OperationMethodPropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'OperationMethod')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 442, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
OperationMethodPropertyType._Automaton = _BuildAutomaton_328()




AbstractGeneralOperationParameterPropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractGeneralOperationParameter'), AbstractGeneralOperationParameterType, abstract=pyxb.binding.datatypes.boolean(1), scope=AbstractGeneralOperationParameterPropertyType, documentation='gml:GeneralOperationParameter is the abstract definition of a parameter or group of parameters used by an operation method.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 446, 1)))

def _BuildAutomaton_329 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_329
    del _BuildAutomaton_329
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 469, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(AbstractGeneralOperationParameterPropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractGeneralOperationParameter')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 470, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
AbstractGeneralOperationParameterPropertyType._Automaton = _BuildAutomaton_329()




OperationParameterPropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'OperationParameter'), OperationParameterType, scope=OperationParameterPropertyType, documentation='gml:OperationParameter is the definition of a parameter used by an operation method. Most parameter values are numeric, but other types of parameter values are possible. This complex type is expected to be used or extended for all operation methods, without defining operation-method-specialized element names.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 474, 1)))

def _BuildAutomaton_330 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_330
    del _BuildAutomaton_330
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 490, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(OperationParameterPropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'OperationParameter')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 491, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
OperationParameterPropertyType._Automaton = _BuildAutomaton_330()




OperationParameterGroupPropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'OperationParameterGroup'), OperationParameterGroupType, scope=OperationParameterGroupPropertyType, documentation='gml:OperationParameterGroup is the definition of a group of parameters used by an operation method. This complex type is expected to be used or extended for all applicable operation methods, without defining operation-method-specialized element names.\nThe generalOperationParameter elements are an unordered list of associations to the set of operation parameters that are members of this group.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 495, 1)))

def _BuildAutomaton_331 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_331
    del _BuildAutomaton_331
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 520, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(OperationParameterGroupPropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'OperationParameterGroup')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 521, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
OperationParameterGroupPropertyType._Automaton = _BuildAutomaton_331()




SingleCRSPropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractSingleCRS'), AbstractCRSType, abstract=pyxb.binding.datatypes.boolean(1), scope=SingleCRSPropertyType, documentation='gml:AbstractSingleCRS implements a coordinate reference system consisting of one coordinate system and one datum (as opposed to a Compound CRS).', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateReferenceSystems.xsd', 18, 1)))

def _BuildAutomaton_332 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_332
    del _BuildAutomaton_332
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateReferenceSystems.xsd', 27, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(SingleCRSPropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractSingleCRS')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateReferenceSystems.xsd', 28, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
SingleCRSPropertyType._Automaton = _BuildAutomaton_332()




CompoundCRSPropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'CompoundCRS'), CompoundCRSType, scope=CompoundCRSPropertyType, documentation='gml:CompundCRS is a coordinate reference system describing the position of points through two or more independent coordinate reference systems. It is associated with a non-repeating sequence of two or more instances of SingleCRS.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateReferenceSystems.xsd', 51, 1)))

def _BuildAutomaton_333 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_333
    del _BuildAutomaton_333
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateReferenceSystems.xsd', 75, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(CompoundCRSPropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'CompoundCRS')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateReferenceSystems.xsd', 76, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
CompoundCRSPropertyType._Automaton = _BuildAutomaton_333()




GeodeticCRSPropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'GeodeticCRS'), GeodeticCRSType, scope=GeodeticCRSPropertyType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateReferenceSystems.xsd', 80, 1)))

def _BuildAutomaton_334 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_334
    del _BuildAutomaton_334
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateReferenceSystems.xsd', 123, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(GeodeticCRSPropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'GeodeticCRS')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateReferenceSystems.xsd', 124, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
GeodeticCRSPropertyType._Automaton = _BuildAutomaton_334()




VerticalCRSPropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'VerticalCRS'), VerticalCRSType, scope=VerticalCRSPropertyType, documentation='gml:VerticalCRS is a 1D coordinate reference system used for recording heights or depths. Vertical CRSs make use of the direction of gravity to define the concept of height or depth, but the relationship with gravity may not be straightforward. By implication, ellipsoidal heights (h) cannot be captured in a vertical coordinate reference system. Ellipsoidal heights cannot exist independently, but only as an inseparable part of a 3D coordinate tuple defined in a geographic 3D coordinate reference system.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateReferenceSystems.xsd', 128, 1)))

def _BuildAutomaton_335 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_335
    del _BuildAutomaton_335
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateReferenceSystems.xsd', 157, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(VerticalCRSPropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'VerticalCRS')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateReferenceSystems.xsd', 158, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
VerticalCRSPropertyType._Automaton = _BuildAutomaton_335()




ProjectedCRSPropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'ProjectedCRS'), ProjectedCRSType, scope=ProjectedCRSPropertyType, documentation='gml:ProjectedCRS is a 2D coordinate reference system used to approximate the shape of the earth on a planar surface, but in such a way that the distortion that is inherent to the approximation is carefully controlled and known. Distortion correction is commonly applied to calculated bearings and distances to produce values that are a close match to actual field values.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateReferenceSystems.xsd', 162, 1)))

def _BuildAutomaton_336 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_336
    del _BuildAutomaton_336
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateReferenceSystems.xsd', 189, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(ProjectedCRSPropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'ProjectedCRS')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateReferenceSystems.xsd', 190, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
ProjectedCRSPropertyType._Automaton = _BuildAutomaton_336()




DerivedCRSPropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'DerivedCRS'), DerivedCRSType, scope=DerivedCRSPropertyType, documentation='gml:DerivedCRS is a single coordinate reference system that is defined by its coordinate conversion from another single coordinate reference system known as the base CRS. The base CRS can be a projected coordinate reference system, if this DerivedCRS is used for a georectified grid coverage as described in ISO 19123, Clause 8.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateReferenceSystems.xsd', 194, 1)))

def _BuildAutomaton_337 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_337
    del _BuildAutomaton_337
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateReferenceSystems.xsd', 229, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(DerivedCRSPropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'DerivedCRS')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateReferenceSystems.xsd', 230, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
DerivedCRSPropertyType._Automaton = _BuildAutomaton_337()




EngineeringCRSPropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'EngineeringCRS'), EngineeringCRSType, scope=EngineeringCRSPropertyType, documentation='gml:EngineeringCRS is a contextually local coordinate reference system which can be divided into two broad categories:\n-\tearth-fixed systems applied to engineering activities on or near the surface of the earth;\n-\tCRSs on moving platforms such as road vehicles, vessels, aircraft, or spacecraft, see ISO 19111 8.3.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateReferenceSystems.xsd', 234, 1)))

def _BuildAutomaton_338 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_338
    del _BuildAutomaton_338
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateReferenceSystems.xsd', 293, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(EngineeringCRSPropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'EngineeringCRS')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateReferenceSystems.xsd', 294, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
EngineeringCRSPropertyType._Automaton = _BuildAutomaton_338()




ImageCRSPropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'ImageCRS'), ImageCRSType, scope=ImageCRSPropertyType, documentation='gml:ImageCRS is an engineering coordinate reference system applied to locations in images. Image coordinate reference systems are treated as a separate sub-type because the definition of the associated image datum contains two attributes not relevant to other engineering datums.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateReferenceSystems.xsd', 298, 1)))

def _BuildAutomaton_339 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_339
    del _BuildAutomaton_339
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateReferenceSystems.xsd', 331, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(ImageCRSPropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'ImageCRS')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateReferenceSystems.xsd', 332, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
ImageCRSPropertyType._Automaton = _BuildAutomaton_339()




TemporalCRSPropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'TemporalCRS'), TemporalCRSType, scope=TemporalCRSPropertyType, documentation='gml:TemporalCRS is a 1D coordinate reference system used for the recording of time.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateReferenceSystems.xsd', 336, 1)))

def _BuildAutomaton_340 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_340
    del _BuildAutomaton_340
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateReferenceSystems.xsd', 368, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(TemporalCRSPropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'TemporalCRS')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateReferenceSystems.xsd', 369, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
TemporalCRSPropertyType._Automaton = _BuildAutomaton_340()




CoordinateSystemAxisPropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'CoordinateSystemAxis'), CoordinateSystemAxisType, scope=CoordinateSystemAxisPropertyType, documentation='gml:CoordinateSystemAxis is a definition of a coordinate system axis.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateSystems.xsd', 19, 1)))

def _BuildAutomaton_341 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_341
    del _BuildAutomaton_341
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateSystems.xsd', 73, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(CoordinateSystemAxisPropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'CoordinateSystemAxis')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateSystems.xsd', 74, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
CoordinateSystemAxisPropertyType._Automaton = _BuildAutomaton_341()




CoordinateSystemPropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractCoordinateSystem'), AbstractCoordinateSystemType, abstract=pyxb.binding.datatypes.boolean(1), scope=CoordinateSystemPropertyType, documentation='gml:AbstractCoordinateSystem is a coordinate system (CS) is the non-repeating sequence of coordinate system axes that spans a given coordinate space. A CS is derived from a set of mathematical rules for specifying how coordinates in a given space are to be assigned to points. The coordinate values in a coordinate tuple shall be recorded in the order in which the coordinate system axes associations are recorded. This abstract complex type shall not be used, extended, or restricted, in an Application Schema, to define a concrete subtype with a meaning equivalent to a concrete subtype specified in this document.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateSystems.xsd', 78, 1)))

def _BuildAutomaton_342 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_342
    del _BuildAutomaton_342
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateSystems.xsd', 102, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(CoordinateSystemPropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractCoordinateSystem')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateSystems.xsd', 103, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
CoordinateSystemPropertyType._Automaton = _BuildAutomaton_342()




EllipsoidalCSPropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'EllipsoidalCS'), EllipsoidalCSType, scope=EllipsoidalCSPropertyType, documentation='gml:EllipsoidalCS is a two- or three-dimensional coordinate system in which position is specified by geodetic latitude, geodetic longitude, and (in the three-dimensional case) ellipsoidal height. An EllipsoidalCS shall have two or three gml:axis property elements; the number of associations shall equal the dimension of the CS.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateSystems.xsd', 107, 1)))

def _BuildAutomaton_343 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_343
    del _BuildAutomaton_343
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateSystems.xsd', 121, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(EllipsoidalCSPropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'EllipsoidalCS')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateSystems.xsd', 122, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
EllipsoidalCSPropertyType._Automaton = _BuildAutomaton_343()




CartesianCSPropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'CartesianCS'), CartesianCSType, scope=CartesianCSPropertyType, documentation='gml:CartesianCS is a 1-, 2-, or 3-dimensional coordinate system. In the 1-dimensional case, it contains a single straight coordinate axis. In the 2- and 3-dimensional cases gives the position of points relative to orthogonal straight axes. In the multi-dimensional case, all axes shall have the same length unit of measure. A CartesianCS shall have one, two, or three gml:axis property elements.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateSystems.xsd', 126, 1)))

def _BuildAutomaton_344 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_344
    del _BuildAutomaton_344
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateSystems.xsd', 140, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(CartesianCSPropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'CartesianCS')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateSystems.xsd', 141, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
CartesianCSPropertyType._Automaton = _BuildAutomaton_344()




VerticalCSPropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'VerticalCS'), VerticalCSType, scope=VerticalCSPropertyType, documentation="gml:VerticalCS is a one-dimensional coordinate system used to record the heights or depths of points. Such a coordinate system is usually dependent on the Earth's gravity field, perhaps loosely as when atmospheric pressure is the basis for the vertical coordinate system axis. A VerticalCS shall have one gml:axis property element.", location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateSystems.xsd', 145, 1)))

def _BuildAutomaton_345 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_345
    del _BuildAutomaton_345
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateSystems.xsd', 159, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(VerticalCSPropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'VerticalCS')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateSystems.xsd', 160, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
VerticalCSPropertyType._Automaton = _BuildAutomaton_345()




TimeCSPropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'TimeCS'), TimeCSType, scope=TimeCSPropertyType, documentation='gml:TimeCS is a one-dimensional coordinate system containing a time axis, used to describe the temporal position of a point in the specified time units from a specified time origin. A TimeCS shall have one gml:axis property element.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateSystems.xsd', 164, 1)))

def _BuildAutomaton_346 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_346
    del _BuildAutomaton_346
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateSystems.xsd', 178, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(TimeCSPropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'TimeCS')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateSystems.xsd', 179, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
TimeCSPropertyType._Automaton = _BuildAutomaton_346()




LinearCSPropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'LinearCS'), LinearCSType, scope=LinearCSPropertyType, documentation='gml:LinearCS is a one-dimensional coordinate system that consists of the points that lie on the single axis described. The associated coordinate is the distance – with or without offset – from the specified datum to the point along the axis. A LinearCS shall have one gml:axis property element.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateSystems.xsd', 183, 1)))

def _BuildAutomaton_347 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_347
    del _BuildAutomaton_347
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateSystems.xsd', 197, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(LinearCSPropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'LinearCS')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateSystems.xsd', 198, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
LinearCSPropertyType._Automaton = _BuildAutomaton_347()




UserDefinedCSPropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'UserDefinedCS'), UserDefinedCSType, scope=UserDefinedCSPropertyType, documentation='gml:UserDefinedCS is a two- or three-dimensional coordinate system that consists of any combination of coordinate axes not covered by any other coordinate system type. A UserDefinedCS shall have two or three gml:axis property elements; the number of property elements shall equal the dimension of the CS.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateSystems.xsd', 202, 1)))

def _BuildAutomaton_348 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_348
    del _BuildAutomaton_348
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateSystems.xsd', 216, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(UserDefinedCSPropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'UserDefinedCS')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateSystems.xsd', 217, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
UserDefinedCSPropertyType._Automaton = _BuildAutomaton_348()




SphericalCSPropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'SphericalCS'), SphericalCSType, scope=SphericalCSPropertyType, documentation='gml:SphericalCS is a three-dimensional coordinate system with one distance measured from the origin and two angular coordinates. A SphericalCS shall have three gml:axis property elements.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateSystems.xsd', 221, 1)))

def _BuildAutomaton_349 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_349
    del _BuildAutomaton_349
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateSystems.xsd', 235, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(SphericalCSPropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'SphericalCS')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateSystems.xsd', 236, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
SphericalCSPropertyType._Automaton = _BuildAutomaton_349()




PolarCSPropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'PolarCS'), PolarCSType, scope=PolarCSPropertyType, documentation='gml:PolarCS ia s two-dimensional coordinate system in which position is specified by the distance from the origin and the angle between the line from the origin to a point and a reference direction. A PolarCS shall have two gml:axis property elements.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateSystems.xsd', 240, 1)))

def _BuildAutomaton_350 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_350
    del _BuildAutomaton_350
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateSystems.xsd', 254, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(PolarCSPropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'PolarCS')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateSystems.xsd', 255, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
PolarCSPropertyType._Automaton = _BuildAutomaton_350()




CylindricalCSPropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'CylindricalCS'), CylindricalCSType, scope=CylindricalCSPropertyType, documentation='gml:CylindricalCS is a three-dimensional coordinate system consisting of a polar coordinate system extended by a straight coordinate axis perpendicular to the plane spanned by the polar coordinate system. A CylindricalCS shall have three gml:axis property elements.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateSystems.xsd', 259, 1)))

def _BuildAutomaton_351 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_351
    del _BuildAutomaton_351
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateSystems.xsd', 273, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(CylindricalCSPropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'CylindricalCS')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateSystems.xsd', 274, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
CylindricalCSPropertyType._Automaton = _BuildAutomaton_351()




AffineCSPropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'AffineCS'), AffineCSType, scope=AffineCSPropertyType, documentation='gml:AffineCS is a two- or three-dimensional coordinate system with straight axes that are not necessarily orthogonal. An AffineCS shall have two or three gml:axis property elements; the number of property elements shall equal the dimension of the CS.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateSystems.xsd', 278, 1)))

def _BuildAutomaton_352 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_352
    del _BuildAutomaton_352
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateSystems.xsd', 292, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(AffineCSPropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'AffineCS')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateSystems.xsd', 293, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
AffineCSPropertyType._Automaton = _BuildAutomaton_352()




AbstractCoverageType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'domainSet'), DomainSetType, scope=AbstractCoverageType, documentation='The gml:domainSet property element describes the spatio-temporal region of interest, within which the coverage is defined. Its content model is given by gml:DomainSetType.\nThe value of the domain is thus a choice between a gml:AbstractGeometry and a gml:AbstractTimeObject.  In the instance these abstract elements will normally be substituted by a geometry complex or temporal complex, to represent spatial coverages and time-series, respectively.  \nThe presence of the gml:AssociationAttributeGroup means that domainSet follows the usual GML property model and may use the xlink:href attribute to point to the domain, as an alternative to describing the domain inline. Ownership semantics may be provided using the gml:OwnershipAttributeGroup.\n', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coverage.xsd', 70, 1)))

AbstractCoverageType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'rangeSet'), RangeSetType, scope=AbstractCoverageType, documentation='The gml:rangeSet property element contains the values of the coverage (sometimes called the attribute values).  Its content model is given by gml:RangeSetType.\nThis content model supports a structural description of the range.  The semantic information describing the range set is embedded using a uniform method, as part of the explicit values, or as a template value accompanying the representation using gml:DataBlock and gml:File.\nThe values from each component (or "band") in the range may be encoded within a gml:ValueArray element or a concrete member of the gml:AbstractScalarValueList substitution group . Use of these elements satisfies the value-type homogeneity requirement.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coverage.xsd', 88, 1)))

def _BuildAutomaton_353 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_353
    del _BuildAutomaton_353
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 39, 3))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 40, 3))
    counters.add(cc_1)
    cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 41, 3))
    counters.add(cc_2)
    cc_3 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 42, 3))
    counters.add(cc_3)
    cc_4 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 43, 3))
    counters.add(cc_4)
    cc_5 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/feature.xsd', 26, 5))
    counters.add(cc_5)
    cc_6 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/feature.xsd', 27, 5))
    counters.add(cc_6)
    states = []
    final_update = None
    symbol = pyxb.binding.content.ElementUse(AbstractCoverageType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'metaDataProperty')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 39, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(AbstractCoverageType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'description')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 40, 3))
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(AbstractCoverageType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'descriptionReference')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 41, 3))
    st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(AbstractCoverageType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'identifier')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 42, 3))
    st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_3)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(AbstractCoverageType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'name')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 43, 3))
    st_4 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_4)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(AbstractCoverageType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'boundedBy')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/feature.xsd', 26, 5))
    st_5 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_5)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(AbstractCoverageType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'location')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/feature.xsd', 27, 5))
    st_6 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_6)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(AbstractCoverageType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'domainSet')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coverage.xsd', 28, 5))
    st_7 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_7)
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(AbstractCoverageType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'rangeSet')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coverage.xsd', 29, 5))
    st_8 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_8)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_1, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_1, False) ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_2, True) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_2, False) ]))
    st_2._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_3, True) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_3, False) ]))
    st_3._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_4, True) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_4, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_4, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_4, False) ]))
    st_4._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_5, True) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_5, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_5, False) ]))
    st_5._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_6, True) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_6, False) ]))
    st_6._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_8, [
         ]))
    st_7._set_transitionSet(transitions)
    transitions = []
    st_8._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
AbstractCoverageType._Automaton = _BuildAutomaton_353()




DomainSetType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractGeometry'), AbstractGeometryType, abstract=pyxb.binding.datatypes.boolean(1), scope=DomainSetType, documentation='The AbstractGeometry element is the abstract head of the substitution group for all geometry elements of GML. This includes pre-defined and user-defined geometry elements. Any geometry element shall be a direct or indirect extension/restriction of AbstractGeometryType and shall be directly or indirectly in the substitution group of AbstractGeometry.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic0d1d.xsd', 50, 1)))

DomainSetType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractTimeObject'), AbstractTimeObjectType, abstract=pyxb.binding.datatypes.boolean(1), scope=DomainSetType, documentation='gml:AbstractTimeObject acts as the head of a substitution group for all temporal primitives and complexes.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporal.xsd', 18, 1)))

def _BuildAutomaton_354 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_354
    del _BuildAutomaton_354
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coverage.xsd', 79, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(DomainSetType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractGeometry')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coverage.xsd', 81, 4))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(DomainSetType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractTimeObject')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coverage.xsd', 82, 4))
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_1._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
DomainSetType._Automaton = _BuildAutomaton_354()




DatumPropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractDatum'), AbstractDatumType, abstract=pyxb.binding.datatypes.boolean(1), scope=DatumPropertyType, documentation='A gml:AbstractDatum specifies the relationship of a coordinate system to the earth, thus creating a coordinate reference system. A datum uses a parameter or set of parameters that determine the location of the origin of the coordinate reference system. Each datum subtype may be associated with only specific types of coordinate systems. This abstract complex type shall not be used, extended, or restricted, in a GML Application Schema, to define a concrete subtype with a meaning equivalent to a concrete subtype specified in this document.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/datums.xsd', 21, 1)))

def _BuildAutomaton_355 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_355
    del _BuildAutomaton_355
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/datums.xsd', 56, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(DatumPropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractDatum')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/datums.xsd', 57, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
DatumPropertyType._Automaton = _BuildAutomaton_355()




GeodeticDatumPropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'GeodeticDatum'), GeodeticDatumType, scope=GeodeticDatumPropertyType, documentation='gml:GeodeticDatum is a geodetic datum defines the precise location and orientation in 3-dimensional space of a defined ellipsoid (or sphere), or of a Cartesian coordinate system centered in this ellipsoid (or sphere).', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/datums.xsd', 61, 1)))

def _BuildAutomaton_356 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_356
    del _BuildAutomaton_356
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/datums.xsd', 90, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(GeodeticDatumPropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'GeodeticDatum')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/datums.xsd', 91, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
GeodeticDatumPropertyType._Automaton = _BuildAutomaton_356()




EllipsoidPropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'Ellipsoid'), EllipsoidType, scope=EllipsoidPropertyType, documentation='A gml:Ellipsoid is a geometric figure that may be used to describe the approximate shape of the earth. In mathematical terms, it is a surface formed by the rotation of an ellipse about its minor axis.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/datums.xsd', 95, 1)))

def _BuildAutomaton_357 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_357
    del _BuildAutomaton_357
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/datums.xsd', 140, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(EllipsoidPropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'Ellipsoid')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/datums.xsd', 141, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
EllipsoidPropertyType._Automaton = _BuildAutomaton_357()




PrimeMeridianPropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'PrimeMeridian'), PrimeMeridianType, scope=PrimeMeridianPropertyType, documentation='A gml:PrimeMeridian defines the origin from which longitude values are determined. The default value for the prime meridian gml:identifier value is "Greenwich".', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/datums.xsd', 145, 1)))

def _BuildAutomaton_358 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_358
    del _BuildAutomaton_358
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/datums.xsd', 168, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(PrimeMeridianPropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'PrimeMeridian')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/datums.xsd', 169, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
PrimeMeridianPropertyType._Automaton = _BuildAutomaton_358()




EngineeringDatumPropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'EngineeringDatum'), EngineeringDatumType, scope=EngineeringDatumPropertyType, documentation='gml:EngineeringDatum defines the origin of an engineering coordinate reference system, and is used in a region around that origin. This origin may be fixed with respect to the earth (such as a defined point at a construction site), or be a defined point on a moving vehicle (such as on a ship or satellite).', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/datums.xsd', 173, 1)))

def _BuildAutomaton_359 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_359
    del _BuildAutomaton_359
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/datums.xsd', 187, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(EngineeringDatumPropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'EngineeringDatum')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/datums.xsd', 188, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
EngineeringDatumPropertyType._Automaton = _BuildAutomaton_359()




ImageDatumPropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'ImageDatum'), ImageDatumType, scope=ImageDatumPropertyType, documentation='gml:ImageDatum defines the origin of an image coordinate reference system, and is used in a local context only. For an image datum, the anchor definition is usually either the centre of the image or the corner of the image. For more information, see ISO 19111 B.3.5.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/datums.xsd', 192, 1)))

def _BuildAutomaton_360 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_360
    del _BuildAutomaton_360
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/datums.xsd', 215, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(ImageDatumPropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'ImageDatum')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/datums.xsd', 216, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
ImageDatumPropertyType._Automaton = _BuildAutomaton_360()




VerticalDatumPropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'VerticalDatum'), VerticalDatumType, scope=VerticalDatumPropertyType, documentation='gml:VerticalDatum is a textual description and/or a set of parameters identifying a particular reference level surface used as a zero-height surface, including its position with respect to the Earth for any of the height types recognized by this International Standard.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/datums.xsd', 220, 1)))

def _BuildAutomaton_361 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_361
    del _BuildAutomaton_361
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/datums.xsd', 234, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(VerticalDatumPropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'VerticalDatum')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/datums.xsd', 235, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
VerticalDatumPropertyType._Automaton = _BuildAutomaton_361()




TemporalDatumPropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'TemporalDatum'), TemporalDatumType, scope=TemporalDatumPropertyType, documentation='A gml:TemporalDatum defines the origin of a Temporal Reference System. This type omits the "anchorDefinition" and "realizationEpoch" elements and adds the "origin" element with the dateTime type.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/datums.xsd', 239, 1)))

def _BuildAutomaton_362 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_362
    del _BuildAutomaton_362
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/datums.xsd', 282, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(TemporalDatumPropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'TemporalDatum')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/datums.xsd', 283, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
TemporalDatumPropertyType._Automaton = _BuildAutomaton_362()




OperationPropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractOperation'), AbstractCoordinateOperationType, abstract=pyxb.binding.datatypes.boolean(1), scope=OperationPropertyType, documentation='', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 83, 1)))

def _BuildAutomaton_363 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_363
    del _BuildAutomaton_363
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 92, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(OperationPropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractOperation')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 93, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
OperationPropertyType._Automaton = _BuildAutomaton_363()




TemporalCSPropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'TemporalCS'), TemporalCSType, scope=TemporalCSPropertyType, documentation='', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 247, 1)))

def _BuildAutomaton_364 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_364
    del _BuildAutomaton_364
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 264, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(TemporalCSPropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'TemporalCS')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 265, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
TemporalCSPropertyType._Automaton = _BuildAutomaton_364()




ObliqueCartesianCSPropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'ObliqueCartesianCS'), ObliqueCartesianCSType, scope=ObliqueCartesianCSPropertyType, documentation='', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 299, 1)))

def _BuildAutomaton_365 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_365
    del _BuildAutomaton_365
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 316, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(ObliqueCartesianCSPropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'ObliqueCartesianCS')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 317, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
ObliqueCartesianCSPropertyType._Automaton = _BuildAutomaton_365()




GeographicCRSPropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'GeographicCRS'), GeographicCRSType, scope=GeographicCRSPropertyType, documentation='', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 451, 1)))

def _BuildAutomaton_366 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_366
    del _BuildAutomaton_366
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 473, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(GeographicCRSPropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'GeographicCRS')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 474, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
GeographicCRSPropertyType._Automaton = _BuildAutomaton_366()




GeocentricCRSPropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'GeocentricCRS'), GeocentricCRSType, scope=GeocentricCRSPropertyType, documentation='', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 483, 1)))

def _BuildAutomaton_367 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_367
    del _BuildAutomaton_367
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 508, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(GeocentricCRSPropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'GeocentricCRS')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 509, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
GeocentricCRSPropertyType._Automaton = _BuildAutomaton_367()




MetaDataPropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractMetaData'), AbstractMetaDataType, abstract=pyxb.binding.datatypes.boolean(1), scope=MetaDataPropertyType, documentation='', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 722, 1)))

def _BuildAutomaton_368 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_368
    del _BuildAutomaton_368
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 716, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(MetaDataPropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractMetaData')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 717, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
MetaDataPropertyType._Automaton = _BuildAutomaton_368()




LocationPropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'Null'), NilReasonType, scope=LocationPropertyType, documentation='', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 13, 1)))

LocationPropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'LocationString'), StringOrRefType, scope=LocationPropertyType, documentation='', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 780, 1)))

LocationPropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'LocationKeyWord'), CodeType, scope=LocationPropertyType, documentation='', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 785, 1)))

LocationPropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractGeometry'), AbstractGeometryType, abstract=pyxb.binding.datatypes.boolean(1), scope=LocationPropertyType, documentation='The AbstractGeometry element is the abstract head of the substitution group for all geometry elements of GML. This includes pre-defined and user-defined geometry elements. Any geometry element shall be a direct or indirect extension/restriction of AbstractGeometryType and shall be directly or indirectly in the substitution group of AbstractGeometry.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic0d1d.xsd', 50, 1)))

def _BuildAutomaton_369 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_369
    del _BuildAutomaton_369
    import pyxb.utils.fac as fac

    counters = set()
    states = []
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(LocationPropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractGeometry')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 772, 4))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(LocationPropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'LocationKeyWord')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 773, 4))
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(LocationPropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'LocationString')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 774, 4))
    st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(LocationPropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'Null')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 775, 4))
    st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_3)
    transitions = []
    st_0._set_transitionSet(transitions)
    transitions = []
    st_1._set_transitionSet(transitions)
    transitions = []
    st_2._set_transitionSet(transitions)
    transitions = []
    st_3._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
LocationPropertyType._Automaton = _BuildAutomaton_369()




def _BuildAutomaton_370 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_370
    del _BuildAutomaton_370
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 39, 3))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 40, 3))
    counters.add(cc_1)
    cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 41, 3))
    counters.add(cc_2)
    cc_3 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 42, 3))
    counters.add(cc_3)
    cc_4 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 43, 3))
    counters.add(cc_4)
    cc_5 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 837, 5))
    counters.add(cc_5)
    states = []
    final_update = None
    symbol = pyxb.binding.content.ElementUse(BoundedFeatureType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'metaDataProperty')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 39, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(BoundedFeatureType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'description')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 40, 3))
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(BoundedFeatureType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'descriptionReference')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 41, 3))
    st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(BoundedFeatureType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'identifier')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 42, 3))
    st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_3)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(BoundedFeatureType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'name')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 43, 3))
    st_4 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_4)
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(BoundedFeatureType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'boundedBy')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 836, 5))
    st_5 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_5)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_5, False))
    symbol = pyxb.binding.content.ElementUse(BoundedFeatureType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'location')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 837, 5))
    st_6 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_6)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_1, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_1, False) ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_2, True) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_2, False) ]))
    st_2._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_3, True) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_3, False) ]))
    st_3._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_4, True) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_4, False) ]))
    st_4._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_6, [
         ]))
    st_5._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_5, True) ]))
    st_6._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
BoundedFeatureType._Automaton = _BuildAutomaton_370()




AbstractFeatureCollectionType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'featureMember'), FeaturePropertyType, scope=AbstractFeatureCollectionType, documentation='', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 805, 1)))

AbstractFeatureCollectionType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'featureMembers'), FeatureArrayPropertyType, scope=AbstractFeatureCollectionType, documentation='', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 823, 1)))

def _BuildAutomaton_371 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_371
    del _BuildAutomaton_371
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 39, 3))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 40, 3))
    counters.add(cc_1)
    cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 41, 3))
    counters.add(cc_2)
    cc_3 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 42, 3))
    counters.add(cc_3)
    cc_4 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 43, 3))
    counters.add(cc_4)
    cc_5 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/feature.xsd', 26, 5))
    counters.add(cc_5)
    cc_6 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/feature.xsd', 27, 5))
    counters.add(cc_6)
    cc_7 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 849, 5))
    counters.add(cc_7)
    cc_8 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 850, 5))
    counters.add(cc_8)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(AbstractFeatureCollectionType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'metaDataProperty')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 39, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_1, False))
    symbol = pyxb.binding.content.ElementUse(AbstractFeatureCollectionType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'description')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 40, 3))
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_2, False))
    symbol = pyxb.binding.content.ElementUse(AbstractFeatureCollectionType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'descriptionReference')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 41, 3))
    st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_3, False))
    symbol = pyxb.binding.content.ElementUse(AbstractFeatureCollectionType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'identifier')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 42, 3))
    st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_3)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_4, False))
    symbol = pyxb.binding.content.ElementUse(AbstractFeatureCollectionType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'name')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 43, 3))
    st_4 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_4)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_5, False))
    symbol = pyxb.binding.content.ElementUse(AbstractFeatureCollectionType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'boundedBy')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/feature.xsd', 26, 5))
    st_5 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_5)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_6, False))
    symbol = pyxb.binding.content.ElementUse(AbstractFeatureCollectionType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'location')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/feature.xsd', 27, 5))
    st_6 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_6)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_7, False))
    symbol = pyxb.binding.content.ElementUse(AbstractFeatureCollectionType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'featureMember')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 849, 5))
    st_7 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_7)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_8, False))
    symbol = pyxb.binding.content.ElementUse(AbstractFeatureCollectionType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'featureMembers')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 850, 5))
    st_8 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_8)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_8, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_1, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_8, [
        fac.UpdateInstruction(cc_1, False) ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_2, True) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_8, [
        fac.UpdateInstruction(cc_2, False) ]))
    st_2._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_3, True) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_8, [
        fac.UpdateInstruction(cc_3, False) ]))
    st_3._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_4, True) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_4, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_4, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_4, False) ]))
    transitions.append(fac.Transition(st_8, [
        fac.UpdateInstruction(cc_4, False) ]))
    st_4._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_5, True) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_5, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_5, False) ]))
    transitions.append(fac.Transition(st_8, [
        fac.UpdateInstruction(cc_5, False) ]))
    st_5._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_6, True) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_6, False) ]))
    transitions.append(fac.Transition(st_8, [
        fac.UpdateInstruction(cc_6, False) ]))
    st_6._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_7, True) ]))
    transitions.append(fac.Transition(st_8, [
        fac.UpdateInstruction(cc_7, False) ]))
    st_7._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_8, [
        fac.UpdateInstruction(cc_8, True) ]))
    st_8._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
AbstractFeatureCollectionType._Automaton = _BuildAutomaton_371()




MovingObjectStatusType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'location'), LocationPropertyType, scope=MovingObjectStatusType, documentation='', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 761, 1)))

MovingObjectStatusType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'position'), GeometryPropertyType, scope=MovingObjectStatusType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 1057, 6)))

MovingObjectStatusType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'speed'), MeasureType, scope=MovingObjectStatusType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 1063, 5)))

MovingObjectStatusType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'bearing'), DirectionPropertyType, scope=MovingObjectStatusType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 1064, 5)))

MovingObjectStatusType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'acceleration'), MeasureType, scope=MovingObjectStatusType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 1065, 5)))

MovingObjectStatusType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'elevation'), MeasureType, scope=MovingObjectStatusType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 1066, 5)))

MovingObjectStatusType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'status'), StringOrRefType, scope=MovingObjectStatusType, documentation='', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 1073, 1)))

MovingObjectStatusType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'statusReference'), ReferenceType, scope=MovingObjectStatusType, documentation='', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 1078, 1)))

MovingObjectStatusType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'locationName'), CodeType, scope=MovingObjectStatusType, documentation='The gml:locationName property element is a convenience property where the text value describes the location of the feature. If the location names are selected from a controlled list, then the list shall be identified in the codeSpace attribute.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/feature.xsd', 76, 1)))

MovingObjectStatusType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'locationReference'), ReferenceType, scope=MovingObjectStatusType, documentation='The gml:locationReference property element is a convenience property where the text value referenced by the xlink:href attribute describes the location of the feature.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/feature.xsd', 81, 1)))

MovingObjectStatusType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'pos'), DirectPositionType, scope=MovingObjectStatusType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic0d1d.xsd', 87, 1)))

def _BuildAutomaton_372 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_372
    del _BuildAutomaton_372
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 39, 3))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 40, 3))
    counters.add(cc_1)
    cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 41, 3))
    counters.add(cc_2)
    cc_3 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 42, 3))
    counters.add(cc_3)
    cc_4 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 43, 3))
    counters.add(cc_4)
    cc_5 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dynamicFeature.xsd', 92, 5))
    counters.add(cc_5)
    cc_6 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 1063, 5))
    counters.add(cc_6)
    cc_7 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 1064, 5))
    counters.add(cc_7)
    cc_8 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 1065, 5))
    counters.add(cc_8)
    cc_9 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 1066, 5))
    counters.add(cc_9)
    cc_10 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 1067, 5))
    counters.add(cc_10)
    cc_11 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 1068, 5))
    counters.add(cc_11)
    states = []
    final_update = None
    symbol = pyxb.binding.content.ElementUse(MovingObjectStatusType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'metaDataProperty')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 39, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(MovingObjectStatusType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'description')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 40, 3))
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(MovingObjectStatusType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'descriptionReference')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 41, 3))
    st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(MovingObjectStatusType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'identifier')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 42, 3))
    st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_3)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(MovingObjectStatusType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'name')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 43, 3))
    st_4 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_4)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(MovingObjectStatusType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'validTime')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dynamicFeature.xsd', 91, 5))
    st_5 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_5)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(MovingObjectStatusType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'dataSource')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dynamicFeature.xsd', 92, 5))
    st_6 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_6)
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(MovingObjectStatusType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'position')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 1057, 6))
    st_7 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_7)
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(MovingObjectStatusType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'pos')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 1058, 6))
    st_8 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_8)
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(MovingObjectStatusType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'locationName')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 1059, 6))
    st_9 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_9)
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(MovingObjectStatusType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'locationReference')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 1060, 6))
    st_10 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_10)
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(MovingObjectStatusType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'location')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 1061, 6))
    st_11 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_11)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_6, False))
    symbol = pyxb.binding.content.ElementUse(MovingObjectStatusType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'speed')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 1063, 5))
    st_12 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_12)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_7, False))
    symbol = pyxb.binding.content.ElementUse(MovingObjectStatusType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'bearing')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 1064, 5))
    st_13 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_13)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_8, False))
    symbol = pyxb.binding.content.ElementUse(MovingObjectStatusType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'acceleration')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 1065, 5))
    st_14 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_14)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_9, False))
    symbol = pyxb.binding.content.ElementUse(MovingObjectStatusType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'elevation')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 1066, 5))
    st_15 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_15)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_10, False))
    symbol = pyxb.binding.content.ElementUse(MovingObjectStatusType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'status')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 1067, 5))
    st_16 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_16)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_11, False))
    symbol = pyxb.binding.content.ElementUse(MovingObjectStatusType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'statusReference')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 1068, 5))
    st_17 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_17)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_1, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_1, False) ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_2, True) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_2, False) ]))
    st_2._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_3, True) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_3, False) ]))
    st_3._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_4, True) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_4, False) ]))
    st_4._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_6, [
         ]))
    transitions.append(fac.Transition(st_7, [
         ]))
    transitions.append(fac.Transition(st_8, [
         ]))
    transitions.append(fac.Transition(st_9, [
         ]))
    transitions.append(fac.Transition(st_10, [
         ]))
    transitions.append(fac.Transition(st_11, [
         ]))
    st_5._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_5, True) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_5, False) ]))
    transitions.append(fac.Transition(st_8, [
        fac.UpdateInstruction(cc_5, False) ]))
    transitions.append(fac.Transition(st_9, [
        fac.UpdateInstruction(cc_5, False) ]))
    transitions.append(fac.Transition(st_10, [
        fac.UpdateInstruction(cc_5, False) ]))
    transitions.append(fac.Transition(st_11, [
        fac.UpdateInstruction(cc_5, False) ]))
    st_6._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_12, [
         ]))
    transitions.append(fac.Transition(st_13, [
         ]))
    transitions.append(fac.Transition(st_14, [
         ]))
    transitions.append(fac.Transition(st_15, [
         ]))
    transitions.append(fac.Transition(st_16, [
         ]))
    transitions.append(fac.Transition(st_17, [
         ]))
    st_7._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_12, [
         ]))
    transitions.append(fac.Transition(st_13, [
         ]))
    transitions.append(fac.Transition(st_14, [
         ]))
    transitions.append(fac.Transition(st_15, [
         ]))
    transitions.append(fac.Transition(st_16, [
         ]))
    transitions.append(fac.Transition(st_17, [
         ]))
    st_8._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_12, [
         ]))
    transitions.append(fac.Transition(st_13, [
         ]))
    transitions.append(fac.Transition(st_14, [
         ]))
    transitions.append(fac.Transition(st_15, [
         ]))
    transitions.append(fac.Transition(st_16, [
         ]))
    transitions.append(fac.Transition(st_17, [
         ]))
    st_9._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_12, [
         ]))
    transitions.append(fac.Transition(st_13, [
         ]))
    transitions.append(fac.Transition(st_14, [
         ]))
    transitions.append(fac.Transition(st_15, [
         ]))
    transitions.append(fac.Transition(st_16, [
         ]))
    transitions.append(fac.Transition(st_17, [
         ]))
    st_10._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_12, [
         ]))
    transitions.append(fac.Transition(st_13, [
         ]))
    transitions.append(fac.Transition(st_14, [
         ]))
    transitions.append(fac.Transition(st_15, [
         ]))
    transitions.append(fac.Transition(st_16, [
         ]))
    transitions.append(fac.Transition(st_17, [
         ]))
    st_11._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_12, [
        fac.UpdateInstruction(cc_6, True) ]))
    transitions.append(fac.Transition(st_13, [
        fac.UpdateInstruction(cc_6, False) ]))
    transitions.append(fac.Transition(st_14, [
        fac.UpdateInstruction(cc_6, False) ]))
    transitions.append(fac.Transition(st_15, [
        fac.UpdateInstruction(cc_6, False) ]))
    transitions.append(fac.Transition(st_16, [
        fac.UpdateInstruction(cc_6, False) ]))
    transitions.append(fac.Transition(st_17, [
        fac.UpdateInstruction(cc_6, False) ]))
    st_12._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_13, [
        fac.UpdateInstruction(cc_7, True) ]))
    transitions.append(fac.Transition(st_14, [
        fac.UpdateInstruction(cc_7, False) ]))
    transitions.append(fac.Transition(st_15, [
        fac.UpdateInstruction(cc_7, False) ]))
    transitions.append(fac.Transition(st_16, [
        fac.UpdateInstruction(cc_7, False) ]))
    transitions.append(fac.Transition(st_17, [
        fac.UpdateInstruction(cc_7, False) ]))
    st_13._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_14, [
        fac.UpdateInstruction(cc_8, True) ]))
    transitions.append(fac.Transition(st_15, [
        fac.UpdateInstruction(cc_8, False) ]))
    transitions.append(fac.Transition(st_16, [
        fac.UpdateInstruction(cc_8, False) ]))
    transitions.append(fac.Transition(st_17, [
        fac.UpdateInstruction(cc_8, False) ]))
    st_14._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_15, [
        fac.UpdateInstruction(cc_9, True) ]))
    transitions.append(fac.Transition(st_16, [
        fac.UpdateInstruction(cc_9, False) ]))
    transitions.append(fac.Transition(st_17, [
        fac.UpdateInstruction(cc_9, False) ]))
    st_15._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_16, [
        fac.UpdateInstruction(cc_10, True) ]))
    transitions.append(fac.Transition(st_17, [
        fac.UpdateInstruction(cc_10, False) ]))
    st_16._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_17, [
        fac.UpdateInstruction(cc_11, True) ]))
    st_17._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
MovingObjectStatusType._Automaton = _BuildAutomaton_372()




DefinitionType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'remarks'), pyxb.binding.datatypes.string, scope=DefinitionType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 54, 1)))

def _BuildAutomaton_373 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_373
    del _BuildAutomaton_373
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 35, 5))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 36, 5))
    counters.add(cc_1)
    cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 37, 5))
    counters.add(cc_2)
    cc_3 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 39, 5))
    counters.add(cc_3)
    cc_4 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 49, 5))
    counters.add(cc_4)
    states = []
    final_update = None
    symbol = pyxb.binding.content.ElementUse(DefinitionType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'metaDataProperty')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 35, 5))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(DefinitionType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'description')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 36, 5))
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(DefinitionType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'descriptionReference')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 37, 5))
    st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(DefinitionType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'identifier')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 38, 5))
    st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_3)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_3, False))
    symbol = pyxb.binding.content.ElementUse(DefinitionType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'name')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 39, 5))
    st_4 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_4)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_4, False))
    symbol = pyxb.binding.content.ElementUse(DefinitionType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'remarks')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 49, 5))
    st_5 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_5)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_1, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_1, False) ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_2, True) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_2, False) ]))
    st_2._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
         ]))
    transitions.append(fac.Transition(st_5, [
         ]))
    st_3._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_3, True) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_3, False) ]))
    st_4._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_4, True) ]))
    st_5._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
DefinitionType._Automaton = _BuildAutomaton_373()




DictionaryEntryType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'Definition'), DefinitionType, scope=DictionaryEntryType, documentation='The basic gml:Definition element specifies a definition, which can be included in or referenced by a dictionary. \nThe content model for a generic definition is a derivation from gml:AbstractGMLType.  \nThe gml:description property element shall hold the definition if this can be captured in a simple text string, or the gml:descriptionReference property element may carry a link to a description elsewhere.\nThe gml:identifier element shall provide one identifier identifying this definition. The identifier shall be unique within the dictionaries using this definition. \nThe gml:name elements shall provide zero or more terms and synonyms for which this is the definition.\nThe gml:remarks element shall be used to hold additional textual information that is not conceptually part of the definition but is useful in understanding the definition.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 21, 1)))

def _BuildAutomaton_374 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_374
    del _BuildAutomaton_374
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 83, 4))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(DictionaryEntryType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'Definition')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 84, 5))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
DictionaryEntryType._Automaton = _BuildAutomaton_374()




DirectionPropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'DirectionVector'), DirectionVectorType, scope=DirectionPropertyType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/direction.xsd', 22, 3)))

DirectionPropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'DirectionDescription'), DirectionDescriptionType, scope=DirectionPropertyType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/direction.xsd', 23, 3)))

DirectionPropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'CompassPoint'), CompassPointEnumeration, scope=DirectionPropertyType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/direction.xsd', 24, 3)))

DirectionPropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'DirectionKeyword'), CodeType, scope=DirectionPropertyType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/direction.xsd', 25, 3)))

DirectionPropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'DirectionString'), StringOrRefType, scope=DirectionPropertyType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/direction.xsd', 26, 3)))

def _BuildAutomaton_375 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_375
    del _BuildAutomaton_375
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/direction.xsd', 21, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(DirectionPropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'DirectionVector')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/direction.xsd', 22, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(DirectionPropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'DirectionDescription')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/direction.xsd', 23, 3))
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(DirectionPropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'CompassPoint')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/direction.xsd', 24, 3))
    st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(DirectionPropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'DirectionKeyword')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/direction.xsd', 25, 3))
    st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_3)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(DirectionPropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'DirectionString')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/direction.xsd', 26, 3))
    st_4 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_4)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_2._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_3._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_4._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
DirectionPropertyType._Automaton = _BuildAutomaton_375()




DynamicFeatureType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'dataSource'), StringOrRefType, scope=DynamicFeatureType, documentation='Evidence is represented by a simple gml:dataSource or gml:dataSourceReference property that indicates the source of the temporal data. The remote link attributes of the gml:dataSource element have been deprecated along with its current type.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dynamicFeature.xsd', 17, 1)))

DynamicFeatureType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'dataSourceReference'), ReferenceType, scope=DynamicFeatureType, documentation='Evidence is represented by a simple gml:dataSource or gml:dataSourceReference property that indicates the source of the temporal data.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dynamicFeature.xsd', 22, 1)))

DynamicFeatureType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'history'), HistoryPropertyType, scope=DynamicFeatureType, documentation='A generic sequence of events constitute a gml:history of an object.\nThe gml:history element contains a set of elements in the substitution group headed by the abstract element gml:AbstractTimeSlice, representing the time-varying properties of interest. The history property of a dynamic feature associates a feature instance with a sequence of time slices (i.e. change events) that encapsulate the evolution of the feature.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dynamicFeature.xsd', 97, 1)))

DynamicFeatureType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'validTime'), TimePrimitivePropertyType, scope=DynamicFeatureType, documentation='gml:validTime is a convenience property element.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporal.xsd', 52, 1)))

def _BuildAutomaton_376 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_376
    del _BuildAutomaton_376
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 39, 3))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 40, 3))
    counters.add(cc_1)
    cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 41, 3))
    counters.add(cc_2)
    cc_3 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 42, 3))
    counters.add(cc_3)
    cc_4 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 43, 3))
    counters.add(cc_4)
    cc_5 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/feature.xsd', 26, 5))
    counters.add(cc_5)
    cc_6 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/feature.xsd', 27, 5))
    counters.add(cc_6)
    cc_7 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dynamicFeature.xsd', 32, 3))
    counters.add(cc_7)
    cc_8 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dynamicFeature.xsd', 33, 3))
    counters.add(cc_8)
    cc_9 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dynamicFeature.xsd', 34, 3))
    counters.add(cc_9)
    cc_10 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dynamicFeature.xsd', 35, 3))
    counters.add(cc_10)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(DynamicFeatureType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'metaDataProperty')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 39, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_1, False))
    symbol = pyxb.binding.content.ElementUse(DynamicFeatureType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'description')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 40, 3))
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_2, False))
    symbol = pyxb.binding.content.ElementUse(DynamicFeatureType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'descriptionReference')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 41, 3))
    st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_3, False))
    symbol = pyxb.binding.content.ElementUse(DynamicFeatureType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'identifier')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 42, 3))
    st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_3)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_4, False))
    symbol = pyxb.binding.content.ElementUse(DynamicFeatureType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'name')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 43, 3))
    st_4 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_4)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_5, False))
    symbol = pyxb.binding.content.ElementUse(DynamicFeatureType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'boundedBy')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/feature.xsd', 26, 5))
    st_5 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_5)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_6, False))
    symbol = pyxb.binding.content.ElementUse(DynamicFeatureType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'location')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/feature.xsd', 27, 5))
    st_6 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_6)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_7, False))
    symbol = pyxb.binding.content.ElementUse(DynamicFeatureType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'validTime')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dynamicFeature.xsd', 32, 3))
    st_7 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_7)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_8, False))
    symbol = pyxb.binding.content.ElementUse(DynamicFeatureType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'history')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dynamicFeature.xsd', 33, 3))
    st_8 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_8)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_9, False))
    symbol = pyxb.binding.content.ElementUse(DynamicFeatureType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'dataSource')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dynamicFeature.xsd', 34, 3))
    st_9 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_9)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_10, False))
    symbol = pyxb.binding.content.ElementUse(DynamicFeatureType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'dataSourceReference')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dynamicFeature.xsd', 35, 3))
    st_10 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_10)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_8, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_9, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_10, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_1, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_8, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_9, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_10, [
        fac.UpdateInstruction(cc_1, False) ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_2, True) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_8, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_9, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_10, [
        fac.UpdateInstruction(cc_2, False) ]))
    st_2._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_3, True) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_8, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_9, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_10, [
        fac.UpdateInstruction(cc_3, False) ]))
    st_3._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_4, True) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_4, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_4, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_4, False) ]))
    transitions.append(fac.Transition(st_8, [
        fac.UpdateInstruction(cc_4, False) ]))
    transitions.append(fac.Transition(st_9, [
        fac.UpdateInstruction(cc_4, False) ]))
    transitions.append(fac.Transition(st_10, [
        fac.UpdateInstruction(cc_4, False) ]))
    st_4._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_5, True) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_5, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_5, False) ]))
    transitions.append(fac.Transition(st_8, [
        fac.UpdateInstruction(cc_5, False) ]))
    transitions.append(fac.Transition(st_9, [
        fac.UpdateInstruction(cc_5, False) ]))
    transitions.append(fac.Transition(st_10, [
        fac.UpdateInstruction(cc_5, False) ]))
    st_5._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_6, True) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_6, False) ]))
    transitions.append(fac.Transition(st_8, [
        fac.UpdateInstruction(cc_6, False) ]))
    transitions.append(fac.Transition(st_9, [
        fac.UpdateInstruction(cc_6, False) ]))
    transitions.append(fac.Transition(st_10, [
        fac.UpdateInstruction(cc_6, False) ]))
    st_6._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_7, True) ]))
    transitions.append(fac.Transition(st_8, [
        fac.UpdateInstruction(cc_7, False) ]))
    transitions.append(fac.Transition(st_9, [
        fac.UpdateInstruction(cc_7, False) ]))
    transitions.append(fac.Transition(st_10, [
        fac.UpdateInstruction(cc_7, False) ]))
    st_7._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_8, [
        fac.UpdateInstruction(cc_8, True) ]))
    transitions.append(fac.Transition(st_9, [
        fac.UpdateInstruction(cc_8, False) ]))
    transitions.append(fac.Transition(st_10, [
        fac.UpdateInstruction(cc_8, False) ]))
    st_8._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_9, [
        fac.UpdateInstruction(cc_9, True) ]))
    transitions.append(fac.Transition(st_10, [
        fac.UpdateInstruction(cc_9, False) ]))
    st_9._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_10, [
        fac.UpdateInstruction(cc_10, True) ]))
    st_10._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
DynamicFeatureType._Automaton = _BuildAutomaton_376()




DynamicFeatureMemberType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'DynamicFeature'), DynamicFeatureType, scope=DynamicFeatureMemberType, documentation="States are captured by time-stamped instances of a feature. The content model extends the standard gml:AbstractFeatureType with the gml:dynamicProperties model group.\nEach time-stamped instance represents a 'snapshot' of a feature. The dynamic feature classes will normally be extended to suit particular applications.  A dynamic feature bears either a time stamp or a history.", location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dynamicFeature.xsd', 38, 1)))

def _BuildAutomaton_377 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_377
    del _BuildAutomaton_377
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dynamicFeature.xsd', 72, 5))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(DynamicFeatureMemberType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'DynamicFeature')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dynamicFeature.xsd', 72, 5))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
DynamicFeatureMemberType._Automaton = _BuildAutomaton_377()




FeaturePropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractFeature'), AbstractFeatureType, abstract=pyxb.binding.datatypes.boolean(1), scope=FeaturePropertyType, documentation='This abstract element serves as the head of a substitution group which may contain any elements whose content model is derived from gml:AbstractFeatureType.  This may be used as a variable in the construction of content models.  \ngml:AbstractFeature may be thought of as "anything that is a GML feature" and may be used to define variables or templates in which the value of a GML property is "any feature". This occurs in particular in a GML feature collection where the feature member properties contain one or multiple copies of gml:AbstractFeature respectively.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/feature.xsd', 32, 1)))

def _BuildAutomaton_378 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_378
    del _BuildAutomaton_378
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/feature.xsd', 39, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(FeaturePropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractFeature')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/feature.xsd', 40, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
FeaturePropertyType._Automaton = _BuildAutomaton_378()




BoundingShapeType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'Null'), NilReasonType, scope=BoundingShapeType, documentation='', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 13, 1)))

BoundingShapeType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'Envelope'), EnvelopeType, scope=BoundingShapeType, documentation='Envelope defines an extent using a pair of positions defining opposite corners in arbitrary dimensions. The first direct position is the "lower corner" (a coordinate position consisting of all the minimal ordinates for each dimension for all points within the envelope), the second one the "upper corner" (a coordinate position consisting of all the maximal ordinates for each dimension for all points within the envelope).\nThe use of the properties "coordinates" and "pos" has been deprecated. The explicitly named properties "lowerCorner" and "upperCorner" shall be used instead.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic0d1d.xsd', 148, 1)))

def _BuildAutomaton_379 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_379
    del _BuildAutomaton_379
    import pyxb.utils.fac as fac

    counters = set()
    states = []
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(BoundingShapeType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'Envelope')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/feature.xsd', 53, 4))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(BoundingShapeType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'Null')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/feature.xsd', 54, 4))
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    transitions = []
    st_0._set_transitionSet(transitions)
    transitions = []
    st_1._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
BoundingShapeType._Automaton = _BuildAutomaton_379()




EnvelopeWithTimePeriodType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'beginPosition'), TimePositionType, scope=EnvelopeWithTimePeriodType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/feature.xsd', 69, 5)))

EnvelopeWithTimePeriodType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'endPosition'), TimePositionType, scope=EnvelopeWithTimePeriodType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/feature.xsd', 70, 5)))

def _BuildAutomaton_380 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_380
    del _BuildAutomaton_380
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=2, max=2, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic0d1d.xsd', 139, 3))
    counters.add(cc_0)
    states = []
    final_update = None
    symbol = pyxb.binding.content.ElementUse(EnvelopeWithTimePeriodType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'lowerCorner')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic0d1d.xsd', 136, 4))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(EnvelopeWithTimePeriodType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'upperCorner')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic0d1d.xsd', 137, 4))
    st_1 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(EnvelopeWithTimePeriodType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'pos')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic0d1d.xsd', 139, 3))
    st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(EnvelopeWithTimePeriodType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'coordinates')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic0d1d.xsd', 144, 3))
    st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_3)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(EnvelopeWithTimePeriodType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'beginPosition')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/feature.xsd', 69, 5))
    st_4 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_4)
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(EnvelopeWithTimePeriodType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'endPosition')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/feature.xsd', 70, 5))
    st_5 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_5)
    transitions = []
    transitions.append(fac.Transition(st_1, [
         ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
         ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_2._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
         ]))
    st_3._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_5, [
         ]))
    st_4._set_transitionSet(transitions)
    transitions = []
    st_5._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
EnvelopeWithTimePeriodType._Automaton = _BuildAutomaton_380()




def _BuildAutomaton_381 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_381
    del _BuildAutomaton_381
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 39, 3))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 40, 3))
    counters.add(cc_1)
    cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 41, 3))
    counters.add(cc_2)
    cc_3 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 42, 3))
    counters.add(cc_3)
    cc_4 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 43, 3))
    counters.add(cc_4)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(AbstractGeometricAggregateType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'metaDataProperty')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 39, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_1, False))
    symbol = pyxb.binding.content.ElementUse(AbstractGeometricAggregateType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'description')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 40, 3))
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_2, False))
    symbol = pyxb.binding.content.ElementUse(AbstractGeometricAggregateType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'descriptionReference')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 41, 3))
    st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_3, False))
    symbol = pyxb.binding.content.ElementUse(AbstractGeometricAggregateType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'identifier')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 42, 3))
    st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_3)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_4, False))
    symbol = pyxb.binding.content.ElementUse(AbstractGeometricAggregateType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'name')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 43, 3))
    st_4 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_4)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_1, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_1, False) ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_2, True) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_2, False) ]))
    st_2._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_3, True) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_3, False) ]))
    st_3._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_4, True) ]))
    st_4._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
AbstractGeometricAggregateType._Automaton = _BuildAutomaton_381()




MultiGeometryPropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractGeometricAggregate'), AbstractGeometricAggregateType, abstract=pyxb.binding.datatypes.boolean(1), scope=MultiGeometryPropertyType, documentation='gml:AbstractGeometricAggregate is the abstract head of the substitution group for all geometric aggregates.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryAggregates.xsd', 22, 1)))

def _BuildAutomaton_382 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_382
    del _BuildAutomaton_382
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryAggregates.xsd', 57, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(MultiGeometryPropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractGeometricAggregate')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryAggregates.xsd', 58, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
MultiGeometryPropertyType._Automaton = _BuildAutomaton_382()




MultiPointPropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'MultiPoint'), MultiPointType, scope=MultiPointPropertyType, documentation='A gml:MultiPoint consists of one or more gml:Points.\nThe members of the geometric aggregate may be specified either using the "standard" property (gml:pointMember) or the array property (gml:pointMembers). It is also valid to use both the "standard" and the array properties in the same collection.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryAggregates.xsd', 73, 1)))

def _BuildAutomaton_383 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_383
    del _BuildAutomaton_383
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryAggregates.xsd', 93, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(MultiPointPropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'MultiPoint')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryAggregates.xsd', 94, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
MultiPointPropertyType._Automaton = _BuildAutomaton_383()




MultiCurvePropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'MultiCurve'), MultiCurveType, scope=MultiCurvePropertyType, documentation='A gml:MultiCurve is defined by one or more gml:AbstractCurves.\nThe members of the geometric aggregate may be specified either using the "standard" property (gml:curveMember) or the array property (gml:curveMembers). It is also valid to use both the "standard" and the array properties in the same collection.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryAggregates.xsd', 109, 1)))

def _BuildAutomaton_384 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_384
    del _BuildAutomaton_384
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryAggregates.xsd', 124, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(MultiCurvePropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'MultiCurve')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryAggregates.xsd', 125, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
MultiCurvePropertyType._Automaton = _BuildAutomaton_384()




MultiSurfacePropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'MultiSurface'), MultiSurfaceType, scope=MultiSurfacePropertyType, documentation='A gml:MultiSurface is defined by one or more gml:AbstractSurfaces.\nThe members of the geometric aggregate may be specified either using the "standard" property (gml:surfaceMember) or the array property (gml:surfaceMembers). It is also valid to use both the "standard" and the array properties in the same collection.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryAggregates.xsd', 140, 1)))

def _BuildAutomaton_385 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_385
    del _BuildAutomaton_385
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryAggregates.xsd', 155, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(MultiSurfacePropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'MultiSurface')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryAggregates.xsd', 156, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
MultiSurfacePropertyType._Automaton = _BuildAutomaton_385()




MultiSolidPropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'MultiSolid'), MultiSolidType, scope=MultiSolidPropertyType, documentation='A gml:MultiSolid is defined by one or more gml:AbstractSolids.\nThe members of the geometric aggregate may be specified either using the "standard" property (gml:solidMember) or the array property (gml:solidMembers). It is also valid to use both the "standard" and the array properties in the same collection.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryAggregates.xsd', 171, 1)))

def _BuildAutomaton_386 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_386
    del _BuildAutomaton_386
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryAggregates.xsd', 191, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(MultiSolidPropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'MultiSolid')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryAggregates.xsd', 192, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
MultiSolidPropertyType._Automaton = _BuildAutomaton_386()




GeometryPropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractGeometry'), AbstractGeometryType, abstract=pyxb.binding.datatypes.boolean(1), scope=GeometryPropertyType, documentation='The AbstractGeometry element is the abstract head of the substitution group for all geometry elements of GML. This includes pre-defined and user-defined geometry elements. Any geometry element shall be a direct or indirect extension/restriction of AbstractGeometryType and shall be directly or indirectly in the substitution group of AbstractGeometry.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic0d1d.xsd', 50, 1)))

def _BuildAutomaton_387 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_387
    del _BuildAutomaton_387
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic0d1d.xsd', 60, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(GeometryPropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractGeometry')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic0d1d.xsd', 61, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
GeometryPropertyType._Automaton = _BuildAutomaton_387()




def _BuildAutomaton_388 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_388
    del _BuildAutomaton_388
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 39, 3))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 40, 3))
    counters.add(cc_1)
    cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 41, 3))
    counters.add(cc_2)
    cc_3 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 42, 3))
    counters.add(cc_3)
    cc_4 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 43, 3))
    counters.add(cc_4)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(AbstractGeometricPrimitiveType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'metaDataProperty')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 39, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_1, False))
    symbol = pyxb.binding.content.ElementUse(AbstractGeometricPrimitiveType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'description')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 40, 3))
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_2, False))
    symbol = pyxb.binding.content.ElementUse(AbstractGeometricPrimitiveType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'descriptionReference')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 41, 3))
    st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_3, False))
    symbol = pyxb.binding.content.ElementUse(AbstractGeometricPrimitiveType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'identifier')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 42, 3))
    st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_3)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_4, False))
    symbol = pyxb.binding.content.ElementUse(AbstractGeometricPrimitiveType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'name')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 43, 3))
    st_4 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_4)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_1, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_1, False) ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_2, True) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_2, False) ]))
    st_2._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_3, True) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_3, False) ]))
    st_3._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_4, True) ]))
    st_4._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
AbstractGeometricPrimitiveType._Automaton = _BuildAutomaton_388()




GeometricPrimitivePropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractGeometricPrimitive'), AbstractGeometricPrimitiveType, abstract=pyxb.binding.datatypes.boolean(1), scope=GeometricPrimitivePropertyType, documentation='The AbstractGeometricPrimitive element is the abstract head of the substitution group for all (pre- and user-defined) geometric primitives.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic0d1d.xsd', 162, 1)))

def _BuildAutomaton_389 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_389
    del _BuildAutomaton_389
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic0d1d.xsd', 171, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(GeometricPrimitivePropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractGeometricPrimitive')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic0d1d.xsd', 172, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
GeometricPrimitivePropertyType._Automaton = _BuildAutomaton_389()




PointPropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'Point'), PointType, scope=PointPropertyType, documentation='A Point is defined by a single coordinate tuple. The direct position of a point is specified by the pos element which is of type DirectPositionType.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic0d1d.xsd', 189, 1)))

def _BuildAutomaton_390 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_390
    del _BuildAutomaton_390
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic0d1d.xsd', 198, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(PointPropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'Point')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic0d1d.xsd', 199, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
PointPropertyType._Automaton = _BuildAutomaton_390()




CurvePropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractCurve'), AbstractCurveType, abstract=pyxb.binding.datatypes.boolean(1), scope=CurvePropertyType, documentation='The AbstractCurve element is the abstract head of the substitution group for all (continuous) curve elements.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic0d1d.xsd', 226, 1)))

def _BuildAutomaton_391 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_391
    del _BuildAutomaton_391
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic0d1d.xsd', 235, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(CurvePropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractCurve')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic0d1d.xsd', 236, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
CurvePropertyType._Automaton = _BuildAutomaton_391()




SurfacePropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractSurface'), AbstractSurfaceType, abstract=pyxb.binding.datatypes.boolean(1), scope=SurfacePropertyType, documentation='The AbstractSurface element is the abstract head of the substitution group for all (continuous) surface elements.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic2d.xsd', 22, 1)))

def _BuildAutomaton_392 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_392
    del _BuildAutomaton_392
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic2d.xsd', 31, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(SurfacePropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractSurface')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic2d.xsd', 32, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
SurfacePropertyType._Automaton = _BuildAutomaton_392()




GeometricComplexType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'element'), GeometricPrimitivePropertyType, scope=GeometricComplexType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryComplexes.xsd', 22, 5)))

def _BuildAutomaton_393 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_393
    del _BuildAutomaton_393
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 39, 3))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 40, 3))
    counters.add(cc_1)
    cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 41, 3))
    counters.add(cc_2)
    cc_3 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 42, 3))
    counters.add(cc_3)
    cc_4 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 43, 3))
    counters.add(cc_4)
    states = []
    final_update = None
    symbol = pyxb.binding.content.ElementUse(GeometricComplexType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'metaDataProperty')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 39, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(GeometricComplexType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'description')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 40, 3))
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(GeometricComplexType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'descriptionReference')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 41, 3))
    st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(GeometricComplexType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'identifier')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 42, 3))
    st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_3)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(GeometricComplexType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'name')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 43, 3))
    st_4 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_4)
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(GeometricComplexType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'element')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryComplexes.xsd', 22, 5))
    st_5 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_5)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_1, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_1, False) ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_2, True) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_2, False) ]))
    st_2._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_3, True) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_3, False) ]))
    st_3._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_4, True) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_4, False) ]))
    st_4._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_5, [
         ]))
    st_5._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
GeometricComplexType._Automaton = _BuildAutomaton_393()




GeometricComplexPropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'GeometricComplex'), GeometricComplexType, scope=GeometricComplexPropertyType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryComplexes.xsd', 28, 1)))

GeometricComplexPropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'CompositeCurve'), CompositeCurveType, scope=GeometricComplexPropertyType, documentation='A gml:CompositeCurve is represented by a sequence of (orientable) curves such that each curve in the sequence terminates at the start point of the subsequent curve in the list. \ncurveMember references or contains inline one curve in the composite curve. \nThe curves are contiguous, the collection of curves is ordered. Therefore, if provided, the aggregationType attribute shall have the value "sequence".', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryComplexes.xsd', 54, 1)))

GeometricComplexPropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'CompositeSurface'), CompositeSurfaceType, scope=GeometricComplexPropertyType, documentation='A gml:CompositeSurface is represented by a set of orientable surfaces. It is geometry type with all the geometric properties of a (primitive) surface. Essentially, a composite surface is a collection of surfaces that join in pairs on common boundary curves and which, when considered as a whole, form a single surface.\nsurfaceMember references or contains inline one surface in the composite surface. \nThe surfaces are contiguous.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryComplexes.xsd', 71, 1)))

GeometricComplexPropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'CompositeSolid'), CompositeSolidType, scope=GeometricComplexPropertyType, documentation='gml:CompositeSolid implements ISO 19107 GM_CompositeSolid (see ISO 19107:2003, 6.6.7) as specified in D.2.3.6. \nA gml:CompositeSolid is represented by a set of orientable surfaces. It is a geometry type with all the geometric properties of a (primitive) solid. Essentially, a composite solid is a collection of solids that join in pairs on common boundary surfaces and which, when considered as a whole, form a single solid. \nsolidMember references or contains one solid in the composite solid. The solids are contiguous.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryComplexes.xsd', 88, 1)))

def _BuildAutomaton_394 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_394
    del _BuildAutomaton_394
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryComplexes.xsd', 33, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(GeometricComplexPropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'GeometricComplex')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryComplexes.xsd', 35, 4))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(GeometricComplexPropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'CompositeCurve')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryComplexes.xsd', 36, 4))
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(GeometricComplexPropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'CompositeSurface')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryComplexes.xsd', 37, 4))
    st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(GeometricComplexPropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'CompositeSolid')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryComplexes.xsd', 38, 4))
    st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_3)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_2._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_3._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
GeometricComplexPropertyType._Automaton = _BuildAutomaton_394()




def _BuildAutomaton_395 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_395
    del _BuildAutomaton_395
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=3, max=3, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 150, 6))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(ArcType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'pos')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 151, 7))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(ArcType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'pointProperty')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 152, 7))
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(ArcType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'pointRep')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 153, 7))
    st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(ArcType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'posList')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 155, 6))
    st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_3)
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(ArcType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'coordinates')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 156, 6))
    st_4 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_4)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_2._set_transitionSet(transitions)
    transitions = []
    st_3._set_transitionSet(transitions)
    transitions = []
    st_4._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
ArcType._Automaton = _BuildAutomaton_395()




def _BuildAutomaton_396 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_396
    del _BuildAutomaton_396
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=2, max=2, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 212, 6))
    counters.add(cc_0)
    states = []
    final_update = None
    symbol = pyxb.binding.content.ElementUse(ArcByBulgeType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'pos')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 213, 7))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(ArcByBulgeType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'pointProperty')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 214, 7))
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(ArcByBulgeType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'pointRep')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 215, 7))
    st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(ArcByBulgeType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'posList')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 217, 6))
    st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_3)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(ArcByBulgeType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'coordinates')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 218, 6))
    st_4 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_4)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(ArcByBulgeType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'bulge')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 220, 5))
    st_5 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_5)
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(ArcByBulgeType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'normal')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 221, 5))
    st_6 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_6)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_2._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_5, [
         ]))
    st_3._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_5, [
         ]))
    st_4._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_6, [
         ]))
    st_5._set_transitionSet(transitions)
    transitions = []
    st_6._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
ArcByBulgeType._Automaton = _BuildAutomaton_396()




def _BuildAutomaton_397 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_397
    del _BuildAutomaton_397
    import pyxb.utils.fac as fac

    counters = set()
    states = []
    final_update = None
    symbol = pyxb.binding.content.ElementUse(CircleByCenterPointType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'pos')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 272, 7))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(CircleByCenterPointType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'pointProperty')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 273, 7))
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(CircleByCenterPointType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'pointRep')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 274, 7))
    st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(CircleByCenterPointType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'posList')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 276, 6))
    st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_3)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(CircleByCenterPointType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'coordinates')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 277, 6))
    st_4 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_4)
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(CircleByCenterPointType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'radius')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 279, 5))
    st_5 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_5)
    transitions = []
    transitions.append(fac.Transition(st_5, [
         ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_5, [
         ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_5, [
         ]))
    st_2._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_5, [
         ]))
    st_3._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_5, [
         ]))
    st_4._set_transitionSet(transitions)
    transitions = []
    st_5._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
CircleByCenterPointType._Automaton = _BuildAutomaton_397()




def _BuildAutomaton_398 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_398
    del _BuildAutomaton_398
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 388, 6))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=2, max=2, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 397, 5))
    counters.add(cc_1)
    states = []
    final_update = None
    symbol = pyxb.binding.content.ElementUse(BezierType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'pos')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 389, 7))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(BezierType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'pointProperty')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 390, 7))
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(BezierType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'pointRep')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 391, 7))
    st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(BezierType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'posList')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 393, 6))
    st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_3)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(BezierType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'coordinates')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 394, 6))
    st_4 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_4)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(BezierType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'degree')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 396, 5))
    st_5 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_5)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_1, False))
    symbol = pyxb.binding.content.ElementUse(BezierType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'knot')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 397, 5))
    st_6 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_6)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_2._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_5, [
         ]))
    st_3._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_5, [
         ]))
    st_4._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_6, [
         ]))
    st_5._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_1, True) ]))
    st_6._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
BezierType._Automaton = _BuildAutomaton_398()




def _BuildAutomaton_399 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_399
    del _BuildAutomaton_399
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=2, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 478, 5))
    counters.add(cc_0)
    states = []
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(GeodesicType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'posList')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 477, 5))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(GeodesicType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'pos')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic0d1d.xsd', 110, 3))
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(GeodesicType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'pointProperty')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic0d1d.xsd', 111, 3))
    st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    transitions = []
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_2._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
GeodesicType._Automaton = _BuildAutomaton_399()




AbstractGriddedSurfaceType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'rows'), CTD_ANON_3, scope=AbstractGriddedSurfaceType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 653, 3)))

def _BuildAutomaton_400 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_400
    del _BuildAutomaton_400
    import pyxb.utils.fac as fac

    counters = set()
    states = []
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(AbstractGriddedSurfaceType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'rows')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 653, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
AbstractGriddedSurfaceType._Automaton = _BuildAutomaton_400()




SolidPropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractSolid'), AbstractSolidType, abstract=pyxb.binding.datatypes.boolean(1), scope=SolidPropertyType, documentation='The AbstractSolid element is the abstract head of the substituition group for all (continuous) solid elements.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 775, 1)))

def _BuildAutomaton_401 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_401
    del _BuildAutomaton_401
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 784, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(SolidPropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractSolid')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 785, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
SolidPropertyType._Automaton = _BuildAutomaton_401()




def _BuildAutomaton_402 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_402
    del _BuildAutomaton_402
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 68, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.WildcardUse(pyxb.binding.content.Wildcard(process_contents=pyxb.binding.content.Wildcard.PC_strict, namespace_constraint=pyxb.binding.content.Wildcard.NC_any), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 69, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
AssociationRoleType._Automaton = _BuildAutomaton_402()




GridType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'limits'), GridLimitsType, scope=GridType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/grids.xsd', 27, 5)))

GridType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'axisLabels'), NCNameList, scope=GridType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/grids.xsd', 29, 6)))

GridType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'axisName'), pyxb.binding.datatypes.string, scope=GridType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/grids.xsd', 30, 6)))

def _BuildAutomaton_403 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_403
    del _BuildAutomaton_403
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 39, 3))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 40, 3))
    counters.add(cc_1)
    cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 41, 3))
    counters.add(cc_2)
    cc_3 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 42, 3))
    counters.add(cc_3)
    cc_4 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 43, 3))
    counters.add(cc_4)
    states = []
    final_update = None
    symbol = pyxb.binding.content.ElementUse(GridType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'metaDataProperty')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 39, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(GridType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'description')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 40, 3))
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(GridType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'descriptionReference')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 41, 3))
    st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(GridType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'identifier')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 42, 3))
    st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_3)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(GridType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'name')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 43, 3))
    st_4 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_4)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(GridType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'limits')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/grids.xsd', 27, 5))
    st_5 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_5)
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(GridType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'axisLabels')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/grids.xsd', 29, 6))
    st_6 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_6)
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(GridType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'axisName')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/grids.xsd', 30, 6))
    st_7 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_7)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_1, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_1, False) ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_2, True) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_2, False) ]))
    st_2._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_3, True) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_3, False) ]))
    st_3._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_4, True) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_4, False) ]))
    st_4._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_6, [
         ]))
    transitions.append(fac.Transition(st_7, [
         ]))
    st_5._set_transitionSet(transitions)
    transitions = []
    st_6._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_7, [
         ]))
    st_7._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
GridType._Automaton = _BuildAutomaton_403()




ObservationType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'using'), ProcedurePropertyType, scope=ObservationType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/observation.xsd', 41, 1)))

ObservationType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'target'), TargetPropertyType, scope=ObservationType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/observation.xsd', 49, 1)))

ObservationType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'resultOf'), ResultType, scope=ObservationType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/observation.xsd', 59, 1)))

ObservationType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'validTime'), TimePrimitivePropertyType, scope=ObservationType, documentation='gml:validTime is a convenience property element.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporal.xsd', 52, 1)))

def _BuildAutomaton_404 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_404
    del _BuildAutomaton_404
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 39, 3))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 40, 3))
    counters.add(cc_1)
    cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 41, 3))
    counters.add(cc_2)
    cc_3 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 42, 3))
    counters.add(cc_3)
    cc_4 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 43, 3))
    counters.add(cc_4)
    cc_5 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/feature.xsd', 26, 5))
    counters.add(cc_5)
    cc_6 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/feature.xsd', 27, 5))
    counters.add(cc_6)
    cc_7 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/observation.xsd', 34, 5))
    counters.add(cc_7)
    cc_8 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/observation.xsd', 35, 5))
    counters.add(cc_8)
    states = []
    final_update = None
    symbol = pyxb.binding.content.ElementUse(ObservationType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'metaDataProperty')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 39, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(ObservationType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'description')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 40, 3))
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(ObservationType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'descriptionReference')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 41, 3))
    st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(ObservationType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'identifier')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 42, 3))
    st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_3)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(ObservationType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'name')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 43, 3))
    st_4 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_4)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(ObservationType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'boundedBy')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/feature.xsd', 26, 5))
    st_5 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_5)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(ObservationType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'location')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/feature.xsd', 27, 5))
    st_6 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_6)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(ObservationType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'validTime')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/observation.xsd', 33, 5))
    st_7 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_7)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(ObservationType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'using')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/observation.xsd', 34, 5))
    st_8 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_8)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(ObservationType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'target')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/observation.xsd', 35, 5))
    st_9 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_9)
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(ObservationType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'resultOf')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/observation.xsd', 36, 5))
    st_10 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_10)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_1, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_1, False) ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_2, True) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_2, False) ]))
    st_2._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_3, True) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_3, False) ]))
    st_3._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_4, True) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_4, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_4, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_4, False) ]))
    st_4._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_5, True) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_5, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_5, False) ]))
    st_5._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_6, True) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_6, False) ]))
    st_6._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_8, [
         ]))
    transitions.append(fac.Transition(st_9, [
         ]))
    transitions.append(fac.Transition(st_10, [
         ]))
    st_7._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_8, [
        fac.UpdateInstruction(cc_7, True) ]))
    transitions.append(fac.Transition(st_9, [
        fac.UpdateInstruction(cc_7, False) ]))
    transitions.append(fac.Transition(st_10, [
        fac.UpdateInstruction(cc_7, False) ]))
    st_8._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_9, [
        fac.UpdateInstruction(cc_8, True) ]))
    transitions.append(fac.Transition(st_10, [
        fac.UpdateInstruction(cc_8, False) ]))
    st_9._set_transitionSet(transitions)
    transitions = []
    st_10._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
ObservationType._Automaton = _BuildAutomaton_404()




ProcedurePropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractFeature'), AbstractFeatureType, abstract=pyxb.binding.datatypes.boolean(1), scope=ProcedurePropertyType, documentation='This abstract element serves as the head of a substitution group which may contain any elements whose content model is derived from gml:AbstractFeatureType.  This may be used as a variable in the construction of content models.  \ngml:AbstractFeature may be thought of as "anything that is a GML feature" and may be used to define variables or templates in which the value of a GML property is "any feature". This occurs in particular in a GML feature collection where the feature member properties contain one or multiple copies of gml:AbstractFeature respectively.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/feature.xsd', 32, 1)))

def _BuildAutomaton_405 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_405
    del _BuildAutomaton_405
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/observation.xsd', 43, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(ProcedurePropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractFeature')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/observation.xsd', 44, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
ProcedurePropertyType._Automaton = _BuildAutomaton_405()




TargetPropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractFeature'), AbstractFeatureType, abstract=pyxb.binding.datatypes.boolean(1), scope=TargetPropertyType, documentation='This abstract element serves as the head of a substitution group which may contain any elements whose content model is derived from gml:AbstractFeatureType.  This may be used as a variable in the construction of content models.  \ngml:AbstractFeature may be thought of as "anything that is a GML feature" and may be used to define variables or templates in which the value of a GML property is "any feature". This occurs in particular in a GML feature collection where the feature member properties contain one or multiple copies of gml:AbstractFeature respectively.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/feature.xsd', 32, 1)))

TargetPropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractGeometry'), AbstractGeometryType, abstract=pyxb.binding.datatypes.boolean(1), scope=TargetPropertyType, documentation='The AbstractGeometry element is the abstract head of the substitution group for all geometry elements of GML. This includes pre-defined and user-defined geometry elements. Any geometry element shall be a direct or indirect extension/restriction of AbstractGeometryType and shall be directly or indirectly in the substitution group of AbstractGeometry.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic0d1d.xsd', 50, 1)))

def _BuildAutomaton_406 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_406
    del _BuildAutomaton_406
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/observation.xsd', 52, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(TargetPropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractFeature')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/observation.xsd', 53, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(TargetPropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractGeometry')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/observation.xsd', 54, 3))
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_1._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
TargetPropertyType._Automaton = _BuildAutomaton_406()




def _BuildAutomaton_407 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_407
    del _BuildAutomaton_407
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/observation.xsd', 61, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.WildcardUse(pyxb.binding.content.Wildcard(process_contents=pyxb.binding.content.Wildcard.PC_strict, namespace_constraint=pyxb.binding.content.Wildcard.NC_any), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/observation.xsd', 62, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
ResultType._Automaton = _BuildAutomaton_407()




CTD_ANON_8._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'EX_Extent'), EX_Extent_Type, scope=CTD_ANON_8, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/extent.xsd', 104, 1)))

def _BuildAutomaton_408 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_408
    del _BuildAutomaton_408
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/referenceSystems.xsd', 50, 3))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(CTD_ANON_8._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'EX_Extent')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/referenceSystems.xsd', 51, 4))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
CTD_ANON_8._Automaton = _BuildAutomaton_408()




CRSPropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractCRS'), AbstractCRSType, abstract=pyxb.binding.datatypes.boolean(1), scope=CRSPropertyType, documentation='gml:AbstractCRS specifies a coordinate reference system which is usually single but may be compound. This abstract complex type shall not be used, extended, or restricted, in a GML Application Schema, to define a concrete subtype with a meaning equivalent to a concrete subtype specified in this document.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/referenceSystems.xsd', 30, 1)))

def _BuildAutomaton_409 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_409
    del _BuildAutomaton_409
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/referenceSystems.xsd', 65, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(CRSPropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractCRS')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/referenceSystems.xsd', 66, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
CRSPropertyType._Automaton = _BuildAutomaton_409()




AbstractTimePrimitiveType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'relatedTime'), RelatedTimeType, scope=AbstractTimePrimitiveType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporal.xsd', 37, 5)))

def _BuildAutomaton_410 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_410
    del _BuildAutomaton_410
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 39, 3))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 40, 3))
    counters.add(cc_1)
    cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 41, 3))
    counters.add(cc_2)
    cc_3 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 42, 3))
    counters.add(cc_3)
    cc_4 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 43, 3))
    counters.add(cc_4)
    cc_5 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporal.xsd', 37, 5))
    counters.add(cc_5)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(AbstractTimePrimitiveType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'metaDataProperty')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 39, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_1, False))
    symbol = pyxb.binding.content.ElementUse(AbstractTimePrimitiveType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'description')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 40, 3))
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_2, False))
    symbol = pyxb.binding.content.ElementUse(AbstractTimePrimitiveType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'descriptionReference')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 41, 3))
    st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_3, False))
    symbol = pyxb.binding.content.ElementUse(AbstractTimePrimitiveType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'identifier')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 42, 3))
    st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_3)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_4, False))
    symbol = pyxb.binding.content.ElementUse(AbstractTimePrimitiveType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'name')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 43, 3))
    st_4 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_4)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_5, False))
    symbol = pyxb.binding.content.ElementUse(AbstractTimePrimitiveType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'relatedTime')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporal.xsd', 37, 5))
    st_5 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_5)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_1, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_1, False) ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_2, True) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_2, False) ]))
    st_2._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_3, True) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_3, False) ]))
    st_3._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_4, True) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_4, False) ]))
    st_4._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_5, True) ]))
    st_5._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
AbstractTimePrimitiveType._Automaton = _BuildAutomaton_410()




TimePrimitivePropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractTimePrimitive'), AbstractTimePrimitiveType, abstract=pyxb.binding.datatypes.boolean(1), scope=TimePrimitivePropertyType, documentation='gml:AbstractTimePrimitive acts as the head of a substitution group for geometric and topological temporal primitives.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporal.xsd', 28, 1)))

def _BuildAutomaton_411 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_411
    del _BuildAutomaton_411
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporal.xsd', 46, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(TimePrimitivePropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractTimePrimitive')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporal.xsd', 47, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
TimePrimitivePropertyType._Automaton = _BuildAutomaton_411()




def _BuildAutomaton_412 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_412
    del _BuildAutomaton_412
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 39, 3))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 40, 3))
    counters.add(cc_1)
    cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 41, 3))
    counters.add(cc_2)
    cc_3 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 42, 3))
    counters.add(cc_3)
    cc_4 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 43, 3))
    counters.add(cc_4)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(AbstractTimeComplexType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'metaDataProperty')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 39, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_1, False))
    symbol = pyxb.binding.content.ElementUse(AbstractTimeComplexType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'description')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 40, 3))
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_2, False))
    symbol = pyxb.binding.content.ElementUse(AbstractTimeComplexType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'descriptionReference')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 41, 3))
    st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_3, False))
    symbol = pyxb.binding.content.ElementUse(AbstractTimeComplexType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'identifier')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 42, 3))
    st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_3)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_4, False))
    symbol = pyxb.binding.content.ElementUse(AbstractTimeComplexType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'name')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 43, 3))
    st_4 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_4)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_1, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_1, False) ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_2, True) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_2, False) ]))
    st_2._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_3, True) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_3, False) ]))
    st_3._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_4, True) ]))
    st_4._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
AbstractTimeComplexType._Automaton = _BuildAutomaton_412()




TimeInstantPropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'TimeInstant'), TimeInstantType, scope=TimeInstantPropertyType, documentation='gml:TimeInstant acts as a zero-dimensional geometric primitive that represents an identifiable position in time.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporal.xsd', 109, 1)))

def _BuildAutomaton_413 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_413
    del _BuildAutomaton_413
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporal.xsd', 127, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(TimeInstantPropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'TimeInstant')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporal.xsd', 128, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
TimeInstantPropertyType._Automaton = _BuildAutomaton_413()




TimePeriodPropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'TimePeriod'), TimePeriodType, scope=TimePeriodPropertyType, documentation='gml:TimePeriod acts as a one-dimensional geometric primitive that represents an identifiable extent in time.\nThe location in of a gml:TimePeriod is described by the temporal positions of the instants at which it begins and ends. The length of the period is equal to the temporal distance between the two bounding temporal positions. \nBoth beginning and end may be described in terms of their direct position using gml:TimePositionType which is an XML Schema simple content type, or by reference to an indentifiable time instant using gml:TimeInstantPropertyType.\nAlternatively a limit of a gml:TimePeriod may use the conventional GML property model to make a reference to a time instant described elsewhere, or a limit may be indicated as a direct position.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporal.xsd', 133, 1)))

def _BuildAutomaton_414 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_414
    del _BuildAutomaton_414
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporal.xsd', 162, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(TimePeriodPropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'TimePeriod')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporal.xsd', 163, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
TimePeriodPropertyType._Automaton = _BuildAutomaton_414()




TimeCalendarPropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'TimeCalendar'), TimeCalendarType, scope=TimeCalendarPropertyType, documentation='A calendar is a discrete temporal reference system that provides a basis for defining temporal position to a resolution of one day.\ngml:TimeCalendar adds one property to those inherited from gml:TimeReferenceSystem. A gml:referenceFrame provides a link to a gml:TimeCalendarEra that it uses. A  gml:TimeCalendar may reference more than one calendar era. \nThe referenceFrame element follows the standard GML property model, allowing the association to be instantiated either using an inline description using the gml:TimeCalendarEra element, or a link to a gml:TimeCalendarEra which is explicit elsewhere.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporalReferenceSystems.xsd', 53, 1)))

def _BuildAutomaton_415 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_415
    del _BuildAutomaton_415
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporalReferenceSystems.xsd', 94, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(TimeCalendarPropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'TimeCalendar')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporalReferenceSystems.xsd', 95, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
TimeCalendarPropertyType._Automaton = _BuildAutomaton_415()




TimeCalendarEraPropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'TimeCalendarEra'), TimeCalendarEraType, scope=TimeCalendarEraPropertyType, documentation='gml:TimeCalendarEra inherits basic properties from gml:DefinitionType and has the following additional properties:\n-\tgml:referenceEvent is the name or description of a mythical or historic event which fixes the position of the base scale of the calendar era.  This is given as text or using a link to description held elsewhere.\n-\tgml:referenceDate specifies the date of the referenceEvent expressed as a date in the given calendar.  In most calendars, this date is the origin (i.e., the first day) of the scale, but this is not always true.\n-\tgml:julianReference specifies the Julian date that corresponds to the reference date.  The Julian day number is an integer value; the Julian date is a decimal value that allows greater resolution.  Transforming calendar dates to and from Julian dates provides a relatively simple basis for transforming dates from one calendar to another.\n-\tgml:epochOfUse is the period for which the calendar era was used as a basis for dating.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporalReferenceSystems.xsd', 69, 1)))

def _BuildAutomaton_416 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_416
    del _BuildAutomaton_416
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporalReferenceSystems.xsd', 104, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(TimeCalendarEraPropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'TimeCalendarEra')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporalReferenceSystems.xsd', 105, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
TimeCalendarEraPropertyType._Automaton = _BuildAutomaton_416()




TimeClockPropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'TimeClock'), TimeClockType, scope=TimeClockPropertyType, documentation='A clock provides a basis for defining temporal position within a day. A clock shall be used with a calendar in order to provide a complete description of a temporal position within a specific day.\ngml:TimeClock adds the following properties to those inherited from gml:TimeReferenceSystemType:\n-\tgml:referenceEvent is the name or description of an event, such as solar noon or sunrise, which fixes the position of the base scale of the clock.\n-\tgml:referenceTime specifies the time of day associated with the reference event expressed as a time of day in the given clock. The reference time is usually the origin of the clock scale. \n-\tgml:utcReference specifies the 24 hour local or UTC time that corresponds to the reference time.\n-\tgml:dateBasis contains or references the calendars that use this clock.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporalReferenceSystems.xsd', 110, 1)))

def _BuildAutomaton_417 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_417
    del _BuildAutomaton_417
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporalReferenceSystems.xsd', 136, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(TimeClockPropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'TimeClock')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporalReferenceSystems.xsd', 137, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
TimeClockPropertyType._Automaton = _BuildAutomaton_417()




TimeOrdinalEraPropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'TimeOrdinalEra'), TimeOrdinalEraType, scope=TimeOrdinalEraPropertyType, documentation='Its content model follows the pattern of gml:TimeEdge, inheriting standard properties from gml:DefinitionType, and adding gml:start, gml:end and gml:extent properties, a set of gml:member properties which indicate ordered gml:TimeOrdinalEra elements, and a gml:group property which points to the parent era.\nThe recursive inclusion of gml:TimeOrdinalEra elements allow the construction of an arbitrary depth hierarchical ordinal reference schema, such that an ordinal era at a given level of the hierarchy includes a sequence of shorter, coterminous ordinal eras.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporalReferenceSystems.xsd', 159, 1)))

def _BuildAutomaton_418 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_418
    del _BuildAutomaton_418
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporalReferenceSystems.xsd', 183, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(TimeOrdinalEraPropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'TimeOrdinalEra')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporalReferenceSystems.xsd', 184, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
TimeOrdinalEraPropertyType._Automaton = _BuildAutomaton_418()




TimeTopologyPrimitivePropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractTimeTopologyPrimitive'), AbstractTimeTopologyPrimitiveType, abstract=pyxb.binding.datatypes.boolean(1), scope=TimeTopologyPrimitivePropertyType, documentation='gml:TimeTopologyPrimitive acts as the head of a substitution group for topological temporal primitives.\nTemporal topology primitives shall imply the ordering information between features or feature properties. The temporal connection of features can be examined if they have temporal topology primitives as values of their properties. Usually, an instantaneous feature associates with a time node, and a static feature associates with a time edge.  A feature with both modes associates with the temporal topology primitive: a supertype of time nodes and time edges.\nA topological primitive is always connected to one or more other topological primitives, and is, therefore, always a member of a topological complex. In a GML instance, this will often be indicated by the primitives being described by elements that are descendents of an element describing a complex. However, in order to support the case where a temporal topological primitive is described in another context, the optional complex property is provided, which carries a reference to the parent temporal topological complex.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporalTopology.xsd', 15, 1)))

def _BuildAutomaton_419 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_419
    del _BuildAutomaton_419
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporalTopology.xsd', 35, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(TimeTopologyPrimitivePropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractTimeTopologyPrimitive')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporalTopology.xsd', 36, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
TimeTopologyPrimitivePropertyType._Automaton = _BuildAutomaton_419()




TimeTopologyComplexPropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'TimeTopologyComplex'), TimeTopologyComplexType, scope=TimeTopologyComplexPropertyType, documentation='A temporal topology complex shall be the connected acyclic directed graph composed of temporal topological primitives, i.e. time nodes and time edges. Because a time edge may not exist without two time nodes on its boundaries, static features have time edges from a temporal topology complex as the values of their temporal properties, regardless of explicit declarations.\nA temporal topology complex expresses a linear or a non-linear graph. A temporal linear graph, composed of a sequence of time edges, provides a lineage described only by "substitution" of feature instances or feature element values. A time node as the start or the end of the graph connects with at least one time edge. A time node other than the start and the end shall connect to at least two time edges: one of starting from the node, and another ending at the node.\nA temporal topological complex is a set of connected temporal topological primitives. The member primtives are indicated, either by reference or by value, using the primitive property.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporalTopology.xsd', 41, 1)))

def _BuildAutomaton_420 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_420
    del _BuildAutomaton_420
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporalTopology.xsd', 61, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(TimeTopologyComplexPropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'TimeTopologyComplex')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporalTopology.xsd', 62, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
TimeTopologyComplexPropertyType._Automaton = _BuildAutomaton_420()




TimeNodePropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'TimeNode'), TimeNodeType, scope=TimeNodePropertyType, documentation='A time node is a zero-dimensional topological primitive that represents an identifiable node in time (it is equivalent to a point in space). A node may act as the termination or initiation of any number of time edges. A time node may be realised as a geometry, its position, whose value is a time instant.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporalTopology.xsd', 67, 1)))

def _BuildAutomaton_421 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_421
    del _BuildAutomaton_421
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporalTopology.xsd', 87, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(TimeNodePropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'TimeNode')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporalTopology.xsd', 88, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
TimeNodePropertyType._Automaton = _BuildAutomaton_421()




TimeEdgePropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'TimeEdge'), TimeEdgeType, scope=TimeEdgePropertyType, documentation='A time edge is a one-dimensional topological primitive. It is an open interval that starts and ends at a node. The edge may be realised as a geometry whose value is a time period.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporalTopology.xsd', 93, 1)))

def _BuildAutomaton_422 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_422
    del _BuildAutomaton_422
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporalTopology.xsd', 113, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(TimeEdgePropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'TimeEdge')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporalTopology.xsd', 114, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
TimeEdgePropertyType._Automaton = _BuildAutomaton_422()




def _BuildAutomaton_423 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_423
    del _BuildAutomaton_423
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 39, 3))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 40, 3))
    counters.add(cc_1)
    cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 41, 3))
    counters.add(cc_2)
    cc_3 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 42, 3))
    counters.add(cc_3)
    cc_4 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 43, 3))
    counters.add(cc_4)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(AbstractTopoPrimitiveType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'metaDataProperty')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 39, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_1, False))
    symbol = pyxb.binding.content.ElementUse(AbstractTopoPrimitiveType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'description')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 40, 3))
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_2, False))
    symbol = pyxb.binding.content.ElementUse(AbstractTopoPrimitiveType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'descriptionReference')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 41, 3))
    st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_3, False))
    symbol = pyxb.binding.content.ElementUse(AbstractTopoPrimitiveType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'identifier')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 42, 3))
    st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_3)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_4, False))
    symbol = pyxb.binding.content.ElementUse(AbstractTopoPrimitiveType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'name')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 43, 3))
    st_4 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_4)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_1, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_1, False) ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_2, True) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_2, False) ]))
    st_2._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_3, True) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_3, False) ]))
    st_3._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_4, True) ]))
    st_4._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
AbstractTopoPrimitiveType._Automaton = _BuildAutomaton_423()




NodeOrEdgePropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'Node'), NodeType, scope=NodeOrEdgePropertyType, documentation='gml:Node represents the 0-dimensional primitive.\nThe optional coboundary of a node (gml:directedEdge) is a sequence of directed edges which are incident on this node. Edges emanating from this node appear in the node coboundary with a negative orientation. \nIf provided, the aggregationType attribute shall have the value "sequence".\nA node may optionally be realised by a 0-dimensional geometric primitive (gml:pointProperty).', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/topology.xsd', 83, 2)))

NodeOrEdgePropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'Edge'), EdgeType, scope=NodeOrEdgePropertyType, documentation='gml:Edge represents the 1-dimensional primitive.\nThe topological boundary of an Edge (gml:directedNode) consists of a negatively directed start Node and a positively directed end Node.   \nThe optional coboundary of an edge (gml:directedFace) is a circular sequence of directed faces which are incident on this edge in document order. In the 2D case, the orientation of the face on the left of the edge is "+"; the orientation of the face on the right on its right is "-". \nIf provided, the aggregationType attribute shall have the value "sequence".\nAn edge may optionally be realised by a 1-dimensional geometric primitive (gml:curveProperty).', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/topology.xsd', 117, 2)))

def _BuildAutomaton_424 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_424
    del _BuildAutomaton_424
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/topology.xsd', 38, 4))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(NodeOrEdgePropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'Node')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/topology.xsd', 39, 6))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(NodeOrEdgePropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'Edge')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/topology.xsd', 40, 6))
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_1._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
NodeOrEdgePropertyType._Automaton = _BuildAutomaton_424()




NodePropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'Node'), NodeType, scope=NodePropertyType, documentation='gml:Node represents the 0-dimensional primitive.\nThe optional coboundary of a node (gml:directedEdge) is a sequence of directed edges which are incident on this node. Edges emanating from this node appear in the node coboundary with a negative orientation. \nIf provided, the aggregationType attribute shall have the value "sequence".\nA node may optionally be realised by a 0-dimensional geometric primitive (gml:pointProperty).', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/topology.xsd', 83, 2)))

def _BuildAutomaton_425 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_425
    del _BuildAutomaton_425
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/topology.xsd', 46, 4))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(NodePropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'Node')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/topology.xsd', 47, 6))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
NodePropertyType._Automaton = _BuildAutomaton_425()




FaceOrTopoSolidPropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'Face'), FaceType, scope=FaceOrTopoSolidPropertyType, documentation='gml:Face represents the 2-dimensional topology primitive.\nThe topological boundary of a face (gml:directedEdge) consists of a sequence of directed edges. If provided, the aggregationType attribute shall have the value "sequence".\nThe optional coboundary of a face (gml:directedTopoSolid) is a pair of directed solids which are bounded by this face. A positively directed solid corresponds to a solid which lies in the direction of the negatively directed normal to the face in any geometric realisation. \nA face may optionally be realised by a 2-dimensional geometric primitive (gml:surfaceProperty).', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/topology.xsd', 157, 2)))

FaceOrTopoSolidPropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'TopoSolid'), TopoSolidType, scope=FaceOrTopoSolidPropertyType, documentation='gml:TopoSolid represents the 3-dimensional topology primitive. \nThe topological boundary of a solid (gml:directedFace) consists of a set of directed faces.\nA solid may optionally be realised by a 3-dimensional geometric primitive (gml:solidProperty).', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/topology.xsd', 195, 2)))

def _BuildAutomaton_426 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_426
    del _BuildAutomaton_426
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/topology.xsd', 53, 4))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(FaceOrTopoSolidPropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'Face')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/topology.xsd', 54, 6))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(FaceOrTopoSolidPropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'TopoSolid')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/topology.xsd', 55, 6))
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_1._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
FaceOrTopoSolidPropertyType._Automaton = _BuildAutomaton_426()




TopoSolidPropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'TopoSolid'), TopoSolidType, scope=TopoSolidPropertyType, documentation='gml:TopoSolid represents the 3-dimensional topology primitive. \nThe topological boundary of a solid (gml:directedFace) consists of a set of directed faces.\nA solid may optionally be realised by a 3-dimensional geometric primitive (gml:solidProperty).', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/topology.xsd', 195, 2)))

def _BuildAutomaton_427 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_427
    del _BuildAutomaton_427
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/topology.xsd', 61, 4))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(TopoSolidPropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'TopoSolid')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/topology.xsd', 62, 6))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
TopoSolidPropertyType._Automaton = _BuildAutomaton_427()




DirectedNodePropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'Node'), NodeType, scope=DirectedNodePropertyType, documentation='gml:Node represents the 0-dimensional primitive.\nThe optional coboundary of a node (gml:directedEdge) is a sequence of directed edges which are incident on this node. Edges emanating from this node appear in the node coboundary with a negative orientation. \nIf provided, the aggregationType attribute shall have the value "sequence".\nA node may optionally be realised by a 0-dimensional geometric primitive (gml:pointProperty).', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/topology.xsd', 83, 2)))

def _BuildAutomaton_428 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_428
    del _BuildAutomaton_428
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/topology.xsd', 97, 4))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(DirectedNodePropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'Node')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/topology.xsd', 98, 6))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
DirectedNodePropertyType._Automaton = _BuildAutomaton_428()




DirectedEdgePropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'Edge'), EdgeType, scope=DirectedEdgePropertyType, documentation='gml:Edge represents the 1-dimensional primitive.\nThe topological boundary of an Edge (gml:directedNode) consists of a negatively directed start Node and a positively directed end Node.   \nThe optional coboundary of an edge (gml:directedFace) is a circular sequence of directed faces which are incident on this edge in document order. In the 2D case, the orientation of the face on the left of the edge is "+"; the orientation of the face on the right on its right is "-". \nIf provided, the aggregationType attribute shall have the value "sequence".\nAn edge may optionally be realised by a 1-dimensional geometric primitive (gml:curveProperty).', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/topology.xsd', 117, 2)))

def _BuildAutomaton_429 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_429
    del _BuildAutomaton_429
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/topology.xsd', 132, 4))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(DirectedEdgePropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'Edge')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/topology.xsd', 133, 6))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
DirectedEdgePropertyType._Automaton = _BuildAutomaton_429()




DirectedFacePropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'Face'), FaceType, scope=DirectedFacePropertyType, documentation='gml:Face represents the 2-dimensional topology primitive.\nThe topological boundary of a face (gml:directedEdge) consists of a sequence of directed edges. If provided, the aggregationType attribute shall have the value "sequence".\nThe optional coboundary of a face (gml:directedTopoSolid) is a pair of directed solids which are bounded by this face. A positively directed solid corresponds to a solid which lies in the direction of the negatively directed normal to the face in any geometric realisation. \nA face may optionally be realised by a 2-dimensional geometric primitive (gml:surfaceProperty).', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/topology.xsd', 157, 2)))

def _BuildAutomaton_430 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_430
    del _BuildAutomaton_430
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/topology.xsd', 171, 4))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(DirectedFacePropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'Face')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/topology.xsd', 172, 6))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
DirectedFacePropertyType._Automaton = _BuildAutomaton_430()




DirectedTopoSolidPropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'TopoSolid'), TopoSolidType, scope=DirectedTopoSolidPropertyType, documentation='gml:TopoSolid represents the 3-dimensional topology primitive. \nThe topological boundary of a solid (gml:directedFace) consists of a set of directed faces.\nA solid may optionally be realised by a 3-dimensional geometric primitive (gml:solidProperty).', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/topology.xsd', 195, 2)))

def _BuildAutomaton_431 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_431
    del _BuildAutomaton_431
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/topology.xsd', 208, 4))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(DirectedTopoSolidPropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'TopoSolid')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/topology.xsd', 209, 6))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
DirectedTopoSolidPropertyType._Automaton = _BuildAutomaton_431()




TopoPointType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'directedNode'), DirectedNodePropertyType, scope=TopoPointType, documentation='A gml:directedNode property element describes the boundary of topology edges and is used in the support of topological point features via the gml:TopoPoint expression, see below. The orientation attribute of type gml:SignType expresses the sense in which the included node is used: start ("-") or end ("+") node.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/topology.xsd', 91, 2)))

def _BuildAutomaton_432 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_432
    del _BuildAutomaton_432
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 39, 3))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 40, 3))
    counters.add(cc_1)
    cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 41, 3))
    counters.add(cc_2)
    cc_3 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 42, 3))
    counters.add(cc_3)
    cc_4 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 43, 3))
    counters.add(cc_4)
    states = []
    final_update = None
    symbol = pyxb.binding.content.ElementUse(TopoPointType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'metaDataProperty')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 39, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(TopoPointType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'description')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 40, 3))
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(TopoPointType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'descriptionReference')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 41, 3))
    st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(TopoPointType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'identifier')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 42, 3))
    st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_3)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(TopoPointType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'name')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 43, 3))
    st_4 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_4)
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(TopoPointType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'directedNode')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/topology.xsd', 219, 10))
    st_5 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_5)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_1, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_1, False) ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_2, True) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_2, False) ]))
    st_2._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_3, True) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_3, False) ]))
    st_3._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_4, True) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_4, False) ]))
    st_4._set_transitionSet(transitions)
    transitions = []
    st_5._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
TopoPointType._Automaton = _BuildAutomaton_432()




TopoCurveType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'directedEdge'), DirectedEdgePropertyType, scope=TopoCurveType, documentation='A gml:directedEdge property element describes the boundary of topology faces, the coBoundary of topology nodes and is used in the support of topological line features via the gml:TopoCurve expression, see below. The orientation attribute of type gml:SignType expresses the sense in which the included edge is used, i.e. forward or reverse.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/topology.xsd', 126, 2)))

def _BuildAutomaton_433 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_433
    del _BuildAutomaton_433
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 39, 3))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 40, 3))
    counters.add(cc_1)
    cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 41, 3))
    counters.add(cc_2)
    cc_3 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 42, 3))
    counters.add(cc_3)
    cc_4 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 43, 3))
    counters.add(cc_4)
    states = []
    final_update = None
    symbol = pyxb.binding.content.ElementUse(TopoCurveType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'metaDataProperty')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 39, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(TopoCurveType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'description')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 40, 3))
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(TopoCurveType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'descriptionReference')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 41, 3))
    st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(TopoCurveType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'identifier')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 42, 3))
    st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_3)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(TopoCurveType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'name')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 43, 3))
    st_4 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_4)
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(TopoCurveType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'directedEdge')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/topology.xsd', 244, 10))
    st_5 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_5)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_1, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_1, False) ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_2, True) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_2, False) ]))
    st_2._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_3, True) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_3, False) ]))
    st_3._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_4, True) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_4, False) ]))
    st_4._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_5, [
         ]))
    st_5._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
TopoCurveType._Automaton = _BuildAutomaton_433()




TopoSurfaceType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'directedFace'), DirectedFacePropertyType, scope=TopoSurfaceType, documentation='The gml:directedFace property element describes the boundary of topology solids, in the coBoundary of topology edges and is used in the support of surface features via the gml:TopoSurface expression, see below. The orientation attribute of type gml:SignType expresses the sense in which the included face is used i.e. inward or outward with respect to the surface normal in any geometric realisation.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/topology.xsd', 165, 2)))

def _BuildAutomaton_434 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_434
    del _BuildAutomaton_434
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 39, 3))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 40, 3))
    counters.add(cc_1)
    cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 41, 3))
    counters.add(cc_2)
    cc_3 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 42, 3))
    counters.add(cc_3)
    cc_4 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 43, 3))
    counters.add(cc_4)
    states = []
    final_update = None
    symbol = pyxb.binding.content.ElementUse(TopoSurfaceType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'metaDataProperty')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 39, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(TopoSurfaceType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'description')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 40, 3))
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(TopoSurfaceType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'descriptionReference')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 41, 3))
    st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(TopoSurfaceType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'identifier')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 42, 3))
    st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_3)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(TopoSurfaceType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'name')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 43, 3))
    st_4 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_4)
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(TopoSurfaceType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'directedFace')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/topology.xsd', 271, 10))
    st_5 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_5)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_1, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_1, False) ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_2, True) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_2, False) ]))
    st_2._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_3, True) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_3, False) ]))
    st_3._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_4, True) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_4, False) ]))
    st_4._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_5, [
         ]))
    st_5._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
TopoSurfaceType._Automaton = _BuildAutomaton_434()




TopoVolumeType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'directedTopoSolid'), DirectedTopoSolidPropertyType, scope=TopoVolumeType, documentation='The gml:directedSolid property element describes the coBoundary of topology faces and is used in the support of volume features via the gml:TopoVolume expression, see below. The orientation attribute of type gml:SignType expresses the sense in which the included solid appears in the face coboundary. In the context of a gml:TopoVolume the orientation attribute has no meaning.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/topology.xsd', 202, 2)))

def _BuildAutomaton_435 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_435
    del _BuildAutomaton_435
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 39, 3))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 40, 3))
    counters.add(cc_1)
    cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 41, 3))
    counters.add(cc_2)
    cc_3 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 42, 3))
    counters.add(cc_3)
    cc_4 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 43, 3))
    counters.add(cc_4)
    states = []
    final_update = None
    symbol = pyxb.binding.content.ElementUse(TopoVolumeType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'metaDataProperty')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 39, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(TopoVolumeType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'description')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 40, 3))
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(TopoVolumeType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'descriptionReference')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 41, 3))
    st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(TopoVolumeType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'identifier')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 42, 3))
    st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_3)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(TopoVolumeType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'name')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 43, 3))
    st_4 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_4)
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(TopoVolumeType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'directedTopoSolid')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/topology.xsd', 297, 10))
    st_5 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_5)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_1, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_1, False) ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_2, True) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_2, False) ]))
    st_2._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_3, True) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_3, False) ]))
    st_3._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_4, True) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_4, False) ]))
    st_4._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_5, [
         ]))
    st_5._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
TopoVolumeType._Automaton = _BuildAutomaton_435()




TopoComplexType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'subComplex'), TopoComplexPropertyType, scope=TopoComplexType, documentation='The property elements gml:subComplex, gml:superComplex and gml:maximalComplex provide an encoding for relationships between topology complexes as described for gml:TopoComplex above.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/topology.xsd', 342, 2)))

TopoComplexType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'superComplex'), TopoComplexPropertyType, scope=TopoComplexType, documentation='The property elements gml:subComplex, gml:superComplex and gml:maximalComplex provide an encoding for relationships between topology complexes as described for gml:TopoComplex above.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/topology.xsd', 347, 2)))

TopoComplexType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'maximalComplex'), TopoComplexPropertyType, scope=TopoComplexType, documentation='The property elements gml:subComplex, gml:superComplex and gml:maximalComplex provide an encoding for relationships between topology complexes as described for gml:TopoComplex above.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/topology.xsd', 352, 2)))

TopoComplexType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'topoPrimitiveMember'), TopoPrimitiveMemberType, scope=TopoComplexType, documentation='The gml:topoPrimitiveMember property element encodes for the relationship between a topology complex and a single topology primitive.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/topology.xsd', 357, 2)))

TopoComplexType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'topoPrimitiveMembers'), TopoPrimitiveArrayAssociationType, scope=TopoComplexType, documentation='The gml:topoPrimitiveMembers property element encodes the relationship between a topology complex and an arbitrary number of topology primitives.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/topology.xsd', 369, 2)))

def _BuildAutomaton_436 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_436
    del _BuildAutomaton_436
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 39, 3))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 40, 3))
    counters.add(cc_1)
    cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 41, 3))
    counters.add(cc_2)
    cc_3 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 42, 3))
    counters.add(cc_3)
    cc_4 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 43, 3))
    counters.add(cc_4)
    cc_5 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/topology.xsd', 324, 10))
    counters.add(cc_5)
    cc_6 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/topology.xsd', 325, 10))
    counters.add(cc_6)
    cc_7 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/topology.xsd', 326, 10))
    counters.add(cc_7)
    cc_8 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/topology.xsd', 327, 10))
    counters.add(cc_8)
    states = []
    final_update = None
    symbol = pyxb.binding.content.ElementUse(TopoComplexType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'metaDataProperty')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 39, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(TopoComplexType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'description')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 40, 3))
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(TopoComplexType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'descriptionReference')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 41, 3))
    st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(TopoComplexType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'identifier')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 42, 3))
    st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_3)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(TopoComplexType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'name')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 43, 3))
    st_4 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_4)
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(TopoComplexType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'maximalComplex')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/topology.xsd', 323, 10))
    st_5 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_5)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_5, False))
    symbol = pyxb.binding.content.ElementUse(TopoComplexType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'superComplex')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/topology.xsd', 324, 10))
    st_6 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_6)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_6, False))
    symbol = pyxb.binding.content.ElementUse(TopoComplexType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'subComplex')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/topology.xsd', 325, 10))
    st_7 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_7)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_7, False))
    symbol = pyxb.binding.content.ElementUse(TopoComplexType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'topoPrimitiveMember')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/topology.xsd', 326, 10))
    st_8 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_8)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_8, False))
    symbol = pyxb.binding.content.ElementUse(TopoComplexType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'topoPrimitiveMembers')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/topology.xsd', 327, 10))
    st_9 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_9)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_1, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_1, False) ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_2, True) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_2, False) ]))
    st_2._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_3, True) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_3, False) ]))
    st_3._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_4, True) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_4, False) ]))
    st_4._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_6, [
         ]))
    transitions.append(fac.Transition(st_7, [
         ]))
    transitions.append(fac.Transition(st_8, [
         ]))
    transitions.append(fac.Transition(st_9, [
         ]))
    st_5._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_5, True) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_5, False) ]))
    transitions.append(fac.Transition(st_8, [
        fac.UpdateInstruction(cc_5, False) ]))
    transitions.append(fac.Transition(st_9, [
        fac.UpdateInstruction(cc_5, False) ]))
    st_6._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_6, True) ]))
    transitions.append(fac.Transition(st_8, [
        fac.UpdateInstruction(cc_6, False) ]))
    transitions.append(fac.Transition(st_9, [
        fac.UpdateInstruction(cc_6, False) ]))
    st_7._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_8, [
        fac.UpdateInstruction(cc_7, True) ]))
    transitions.append(fac.Transition(st_9, [
        fac.UpdateInstruction(cc_7, False) ]))
    st_8._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_9, [
        fac.UpdateInstruction(cc_8, True) ]))
    st_9._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
TopoComplexType._Automaton = _BuildAutomaton_436()




TopoPrimitiveMemberType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractTopoPrimitive'), AbstractTopoPrimitiveType, abstract=pyxb.binding.datatypes.boolean(1), scope=TopoPrimitiveMemberType, documentation='gml:AbstractTopoPrimitive acts as the base type for all topological primitives. Topology primitives are the atomic (smallest possible) units of a topology complex. \nEach topology primitive may contain references to other topology primitives of codimension 2 or more (gml:isolated). Conversely, nodes may have faces as containers and nodes and edges may have solids as containers (gml:container).', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/topology.xsd', 31, 2)))

def _BuildAutomaton_437 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_437
    del _BuildAutomaton_437
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/topology.xsd', 363, 4))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(TopoPrimitiveMemberType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractTopoPrimitive')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/topology.xsd', 364, 6))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
TopoPrimitiveMemberType._Automaton = _BuildAutomaton_437()




TopoComplexPropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'TopoComplex'), TopoComplexType, scope=TopoComplexPropertyType, documentation='gml:TopoComplex is a collection of topological primitives.\nEach complex holds a reference to its maximal complex (gml:maximalComplex) and optionally to sub- or super-complexes (gml:subComplex, gml:superComplex). \nA topology complex contains its primitive and sub-complex members.\n', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/topology.xsd', 334, 2)))

def _BuildAutomaton_438 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_438
    del _BuildAutomaton_438
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/topology.xsd', 381, 4))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(TopoComplexPropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'TopoComplex')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/topology.xsd', 382, 6))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
TopoComplexPropertyType._Automaton = _BuildAutomaton_438()




ValuePropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'Null'), NilReasonType, scope=ValuePropertyType, documentation='', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 13, 1)))

ValuePropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractGeometry'), AbstractGeometryType, abstract=pyxb.binding.datatypes.boolean(1), scope=ValuePropertyType, documentation='The AbstractGeometry element is the abstract head of the substitution group for all geometry elements of GML. This includes pre-defined and user-defined geometry elements. Any geometry element shall be a direct or indirect extension/restriction of AbstractGeometryType and shall be directly or indirectly in the substitution group of AbstractGeometry.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic0d1d.xsd', 50, 1)))

ValuePropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractTimeObject'), AbstractTimeObjectType, abstract=pyxb.binding.datatypes.boolean(1), scope=ValuePropertyType, documentation='gml:AbstractTimeObject acts as the head of a substitution group for all temporal primitives and complexes.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporal.xsd', 18, 1)))

ValuePropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractValue'), pyxb.binding.datatypes.anyType, abstract=pyxb.binding.datatypes.boolean(1), scope=ValuePropertyType, documentation='gml:AbstractValue is an abstract element which acts as the head of a substitution group which contains gml:AbstractScalarValue, gml:AbstractScalarValueList, gml:CompositeValue and gml:ValueExtent, and (transitively) the elements in their substitution groups.\nThese elements may be used in an application schema as variables, so that in an XML instance document any member of its substitution group may occur.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/valueObjects.xsd', 70, 1)))

def _BuildAutomaton_439 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_439
    del _BuildAutomaton_439
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/valueObjects.xsd', 108, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(ValuePropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractValue')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/valueObjects.xsd', 91, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(ValuePropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractGeometry')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/valueObjects.xsd', 92, 3))
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(ValuePropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractTimeObject')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/valueObjects.xsd', 93, 3))
    st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(ValuePropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'Null')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/valueObjects.xsd', 94, 3))
    st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_3)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_2._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_3._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
ValuePropertyType._Automaton = _BuildAutomaton_439()




def _BuildAutomaton_440 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_440
    del _BuildAutomaton_440
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 39, 3))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 40, 3))
    counters.add(cc_1)
    cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 41, 3))
    counters.add(cc_2)
    cc_3 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 42, 3))
    counters.add(cc_3)
    cc_4 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 43, 3))
    counters.add(cc_4)
    cc_5 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/valueObjects.xsd', 134, 5))
    counters.add(cc_5)
    cc_6 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/valueObjects.xsd', 135, 5))
    counters.add(cc_6)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(ValueArrayType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'metaDataProperty')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 39, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_1, False))
    symbol = pyxb.binding.content.ElementUse(ValueArrayType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'description')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 40, 3))
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_2, False))
    symbol = pyxb.binding.content.ElementUse(ValueArrayType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'descriptionReference')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 41, 3))
    st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_3, False))
    symbol = pyxb.binding.content.ElementUse(ValueArrayType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'identifier')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 42, 3))
    st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_3)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_4, False))
    symbol = pyxb.binding.content.ElementUse(ValueArrayType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'name')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 43, 3))
    st_4 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_4)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_5, False))
    symbol = pyxb.binding.content.ElementUse(ValueArrayType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'valueComponent')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/valueObjects.xsd', 134, 5))
    st_5 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_5)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_6, False))
    symbol = pyxb.binding.content.ElementUse(ValueArrayType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'valueComponents')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/valueObjects.xsd', 135, 5))
    st_6 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_6)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_1, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_1, False) ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_2, True) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_2, False) ]))
    st_2._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_3, True) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_3, False) ]))
    st_3._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_4, True) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_4, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_4, False) ]))
    st_4._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_5, True) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_5, False) ]))
    st_5._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_6, True) ]))
    st_6._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
ValueArrayType._Automaton = _BuildAutomaton_440()




BooleanPropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'Boolean'), CTD_ANON_9, nillable=pyxb.binding.datatypes.boolean(1), scope=BooleanPropertyType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/valueObjects.xsd', 24, 1)))

def _BuildAutomaton_441 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_441
    del _BuildAutomaton_441
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/valueObjects.xsd', 182, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(BooleanPropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'Boolean')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/valueObjects.xsd', 183, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
BooleanPropertyType._Automaton = _BuildAutomaton_441()




CategoryPropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'Category'), CTD_ANON_10, nillable=pyxb.binding.datatypes.boolean(1), scope=CategoryPropertyType, documentation='A gml:Category has an optional XML attribute codeSpace, whose value is a URI which identifies a dictionary, codelist or authority for the term.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/valueObjects.xsd', 34, 1)))

def _BuildAutomaton_442 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_442
    del _BuildAutomaton_442
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/valueObjects.xsd', 188, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(CategoryPropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'Category')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/valueObjects.xsd', 189, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
CategoryPropertyType._Automaton = _BuildAutomaton_442()




QuantityPropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'Quantity'), CTD_ANON_12, nillable=pyxb.binding.datatypes.boolean(1), scope=QuantityPropertyType, documentation='An XML attribute uom ("unit of measure") is required, whose value is a URI which identifies the definition of a ratio scale or units by which the numeric value shall be multiplied, or an interval or position scale on which the value occurs.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/valueObjects.xsd', 57, 1)))

def _BuildAutomaton_443 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_443
    del _BuildAutomaton_443
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/valueObjects.xsd', 194, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(QuantityPropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'Quantity')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/valueObjects.xsd', 195, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
QuantityPropertyType._Automaton = _BuildAutomaton_443()




CountPropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'Count'), CTD_ANON_11, nillable=pyxb.binding.datatypes.boolean(1), scope=CountPropertyType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/valueObjects.xsd', 47, 1)))

def _BuildAutomaton_444 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_444
    del _BuildAutomaton_444
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/valueObjects.xsd', 200, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(CountPropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'Count')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/valueObjects.xsd', 201, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
CountPropertyType._Automaton = _BuildAutomaton_444()




MD_ImageDescription_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'illuminationElevationAngle'), Real_PropertyType, scope=MD_ImageDescription_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/content.xsd', 74, 5)))

MD_ImageDescription_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'illuminationAzimuthAngle'), Real_PropertyType, scope=MD_ImageDescription_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/content.xsd', 75, 5)))

MD_ImageDescription_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'imagingCondition'), MD_ImagingConditionCode_PropertyType, scope=MD_ImageDescription_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/content.xsd', 76, 5)))

MD_ImageDescription_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'imageQualityCode'), MD_Identifier_PropertyType, scope=MD_ImageDescription_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/content.xsd', 77, 5)))

MD_ImageDescription_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'cloudCoverPercentage'), Real_PropertyType, scope=MD_ImageDescription_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/content.xsd', 78, 5)))

MD_ImageDescription_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'processingLevelCode'), MD_Identifier_PropertyType, scope=MD_ImageDescription_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/content.xsd', 79, 5)))

MD_ImageDescription_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'compressionGenerationQuantity'), Integer_PropertyType, scope=MD_ImageDescription_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/content.xsd', 80, 5)))

MD_ImageDescription_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'triangulationIndicator'), Boolean_PropertyType, scope=MD_ImageDescription_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/content.xsd', 81, 5)))

MD_ImageDescription_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'radiometricCalibrationDataAvailability'), Boolean_PropertyType, scope=MD_ImageDescription_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/content.xsd', 82, 5)))

MD_ImageDescription_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'cameraCalibrationInformationAvailability'), Boolean_PropertyType, scope=MD_ImageDescription_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/content.xsd', 83, 5)))

MD_ImageDescription_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'filmDistortionInformationAvailability'), Boolean_PropertyType, scope=MD_ImageDescription_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/content.xsd', 84, 5)))

MD_ImageDescription_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'lensDistortionInformationAvailability'), Boolean_PropertyType, scope=MD_ImageDescription_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/content.xsd', 85, 5)))

def _BuildAutomaton_445 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_445
    del _BuildAutomaton_445
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/content.xsd', 51, 5))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/content.xsd', 74, 5))
    counters.add(cc_1)
    cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/content.xsd', 75, 5))
    counters.add(cc_2)
    cc_3 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/content.xsd', 76, 5))
    counters.add(cc_3)
    cc_4 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/content.xsd', 77, 5))
    counters.add(cc_4)
    cc_5 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/content.xsd', 78, 5))
    counters.add(cc_5)
    cc_6 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/content.xsd', 79, 5))
    counters.add(cc_6)
    cc_7 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/content.xsd', 80, 5))
    counters.add(cc_7)
    cc_8 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/content.xsd', 81, 5))
    counters.add(cc_8)
    cc_9 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/content.xsd', 82, 5))
    counters.add(cc_9)
    cc_10 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/content.xsd', 83, 5))
    counters.add(cc_10)
    cc_11 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/content.xsd', 84, 5))
    counters.add(cc_11)
    cc_12 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/content.xsd', 85, 5))
    counters.add(cc_12)
    states = []
    final_update = None
    symbol = pyxb.binding.content.ElementUse(MD_ImageDescription_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'attributeDescription')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/content.xsd', 49, 5))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(MD_ImageDescription_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'contentType')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/content.xsd', 50, 5))
    st_1 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(MD_ImageDescription_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'dimension')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/content.xsd', 51, 5))
    st_2 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_1, False))
    symbol = pyxb.binding.content.ElementUse(MD_ImageDescription_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'illuminationElevationAngle')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/content.xsd', 74, 5))
    st_3 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_3)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_2, False))
    symbol = pyxb.binding.content.ElementUse(MD_ImageDescription_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'illuminationAzimuthAngle')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/content.xsd', 75, 5))
    st_4 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_4)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_3, False))
    symbol = pyxb.binding.content.ElementUse(MD_ImageDescription_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'imagingCondition')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/content.xsd', 76, 5))
    st_5 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_5)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_4, False))
    symbol = pyxb.binding.content.ElementUse(MD_ImageDescription_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'imageQualityCode')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/content.xsd', 77, 5))
    st_6 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_6)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_5, False))
    symbol = pyxb.binding.content.ElementUse(MD_ImageDescription_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'cloudCoverPercentage')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/content.xsd', 78, 5))
    st_7 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_7)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_6, False))
    symbol = pyxb.binding.content.ElementUse(MD_ImageDescription_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'processingLevelCode')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/content.xsd', 79, 5))
    st_8 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_8)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_7, False))
    symbol = pyxb.binding.content.ElementUse(MD_ImageDescription_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'compressionGenerationQuantity')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/content.xsd', 80, 5))
    st_9 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_9)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_8, False))
    symbol = pyxb.binding.content.ElementUse(MD_ImageDescription_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'triangulationIndicator')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/content.xsd', 81, 5))
    st_10 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_10)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_9, False))
    symbol = pyxb.binding.content.ElementUse(MD_ImageDescription_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'radiometricCalibrationDataAvailability')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/content.xsd', 82, 5))
    st_11 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_11)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_10, False))
    symbol = pyxb.binding.content.ElementUse(MD_ImageDescription_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'cameraCalibrationInformationAvailability')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/content.xsd', 83, 5))
    st_12 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_12)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_11, False))
    symbol = pyxb.binding.content.ElementUse(MD_ImageDescription_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'filmDistortionInformationAvailability')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/content.xsd', 84, 5))
    st_13 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_13)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_12, False))
    symbol = pyxb.binding.content.ElementUse(MD_ImageDescription_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'lensDistortionInformationAvailability')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/content.xsd', 85, 5))
    st_14 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_14)
    transitions = []
    transitions.append(fac.Transition(st_1, [
         ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_2, [
         ]))
    transitions.append(fac.Transition(st_3, [
         ]))
    transitions.append(fac.Transition(st_4, [
         ]))
    transitions.append(fac.Transition(st_5, [
         ]))
    transitions.append(fac.Transition(st_6, [
         ]))
    transitions.append(fac.Transition(st_7, [
         ]))
    transitions.append(fac.Transition(st_8, [
         ]))
    transitions.append(fac.Transition(st_9, [
         ]))
    transitions.append(fac.Transition(st_10, [
         ]))
    transitions.append(fac.Transition(st_11, [
         ]))
    transitions.append(fac.Transition(st_12, [
         ]))
    transitions.append(fac.Transition(st_13, [
         ]))
    transitions.append(fac.Transition(st_14, [
         ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_8, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_9, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_10, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_11, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_12, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_13, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_14, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_2._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_1, True) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_8, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_9, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_10, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_11, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_12, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_13, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_14, [
        fac.UpdateInstruction(cc_1, False) ]))
    st_3._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_2, True) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_8, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_9, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_10, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_11, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_12, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_13, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_14, [
        fac.UpdateInstruction(cc_2, False) ]))
    st_4._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_3, True) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_8, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_9, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_10, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_11, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_12, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_13, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_14, [
        fac.UpdateInstruction(cc_3, False) ]))
    st_5._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_4, True) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_4, False) ]))
    transitions.append(fac.Transition(st_8, [
        fac.UpdateInstruction(cc_4, False) ]))
    transitions.append(fac.Transition(st_9, [
        fac.UpdateInstruction(cc_4, False) ]))
    transitions.append(fac.Transition(st_10, [
        fac.UpdateInstruction(cc_4, False) ]))
    transitions.append(fac.Transition(st_11, [
        fac.UpdateInstruction(cc_4, False) ]))
    transitions.append(fac.Transition(st_12, [
        fac.UpdateInstruction(cc_4, False) ]))
    transitions.append(fac.Transition(st_13, [
        fac.UpdateInstruction(cc_4, False) ]))
    transitions.append(fac.Transition(st_14, [
        fac.UpdateInstruction(cc_4, False) ]))
    st_6._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_5, True) ]))
    transitions.append(fac.Transition(st_8, [
        fac.UpdateInstruction(cc_5, False) ]))
    transitions.append(fac.Transition(st_9, [
        fac.UpdateInstruction(cc_5, False) ]))
    transitions.append(fac.Transition(st_10, [
        fac.UpdateInstruction(cc_5, False) ]))
    transitions.append(fac.Transition(st_11, [
        fac.UpdateInstruction(cc_5, False) ]))
    transitions.append(fac.Transition(st_12, [
        fac.UpdateInstruction(cc_5, False) ]))
    transitions.append(fac.Transition(st_13, [
        fac.UpdateInstruction(cc_5, False) ]))
    transitions.append(fac.Transition(st_14, [
        fac.UpdateInstruction(cc_5, False) ]))
    st_7._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_8, [
        fac.UpdateInstruction(cc_6, True) ]))
    transitions.append(fac.Transition(st_9, [
        fac.UpdateInstruction(cc_6, False) ]))
    transitions.append(fac.Transition(st_10, [
        fac.UpdateInstruction(cc_6, False) ]))
    transitions.append(fac.Transition(st_11, [
        fac.UpdateInstruction(cc_6, False) ]))
    transitions.append(fac.Transition(st_12, [
        fac.UpdateInstruction(cc_6, False) ]))
    transitions.append(fac.Transition(st_13, [
        fac.UpdateInstruction(cc_6, False) ]))
    transitions.append(fac.Transition(st_14, [
        fac.UpdateInstruction(cc_6, False) ]))
    st_8._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_9, [
        fac.UpdateInstruction(cc_7, True) ]))
    transitions.append(fac.Transition(st_10, [
        fac.UpdateInstruction(cc_7, False) ]))
    transitions.append(fac.Transition(st_11, [
        fac.UpdateInstruction(cc_7, False) ]))
    transitions.append(fac.Transition(st_12, [
        fac.UpdateInstruction(cc_7, False) ]))
    transitions.append(fac.Transition(st_13, [
        fac.UpdateInstruction(cc_7, False) ]))
    transitions.append(fac.Transition(st_14, [
        fac.UpdateInstruction(cc_7, False) ]))
    st_9._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_10, [
        fac.UpdateInstruction(cc_8, True) ]))
    transitions.append(fac.Transition(st_11, [
        fac.UpdateInstruction(cc_8, False) ]))
    transitions.append(fac.Transition(st_12, [
        fac.UpdateInstruction(cc_8, False) ]))
    transitions.append(fac.Transition(st_13, [
        fac.UpdateInstruction(cc_8, False) ]))
    transitions.append(fac.Transition(st_14, [
        fac.UpdateInstruction(cc_8, False) ]))
    st_10._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_11, [
        fac.UpdateInstruction(cc_9, True) ]))
    transitions.append(fac.Transition(st_12, [
        fac.UpdateInstruction(cc_9, False) ]))
    transitions.append(fac.Transition(st_13, [
        fac.UpdateInstruction(cc_9, False) ]))
    transitions.append(fac.Transition(st_14, [
        fac.UpdateInstruction(cc_9, False) ]))
    st_11._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_12, [
        fac.UpdateInstruction(cc_10, True) ]))
    transitions.append(fac.Transition(st_13, [
        fac.UpdateInstruction(cc_10, False) ]))
    transitions.append(fac.Transition(st_14, [
        fac.UpdateInstruction(cc_10, False) ]))
    st_12._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_13, [
        fac.UpdateInstruction(cc_11, True) ]))
    transitions.append(fac.Transition(st_14, [
        fac.UpdateInstruction(cc_11, False) ]))
    st_13._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_14, [
        fac.UpdateInstruction(cc_12, True) ]))
    st_14._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
MD_ImageDescription_Type._Automaton = _BuildAutomaton_445()




def _BuildAutomaton_446 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_446
    del _BuildAutomaton_446
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 479, 5))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 480, 5))
    counters.add(cc_1)
    cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 481, 5))
    counters.add(cc_2)
    cc_3 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 482, 5))
    counters.add(cc_3)
    cc_4 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 483, 5))
    counters.add(cc_4)
    cc_5 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 484, 5))
    counters.add(cc_5)
    cc_6 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 485, 5))
    counters.add(cc_6)
    cc_7 = fac.CounterCondition(min=1, max=2, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 486, 5))
    counters.add(cc_7)
    states = []
    final_update = None
    symbol = pyxb.binding.content.ElementUse(DQ_TemporalValidity_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'nameOfMeasure')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 479, 5))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(DQ_TemporalValidity_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'measureIdentification')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 480, 5))
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(DQ_TemporalValidity_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'measureDescription')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 481, 5))
    st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(DQ_TemporalValidity_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'evaluationMethodType')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 482, 5))
    st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_3)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(DQ_TemporalValidity_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'evaluationMethodDescription')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 483, 5))
    st_4 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_4)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(DQ_TemporalValidity_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'evaluationProcedure')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 484, 5))
    st_5 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_5)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(DQ_TemporalValidity_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'dateTime')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 485, 5))
    st_6 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_6)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_7, False))
    symbol = pyxb.binding.content.ElementUse(DQ_TemporalValidity_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'result')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 486, 5))
    st_7 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_7)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_1, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_1, False) ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_2, True) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_2, False) ]))
    st_2._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_3, True) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_3, False) ]))
    st_3._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_4, True) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_4, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_4, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_4, False) ]))
    st_4._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_5, True) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_5, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_5, False) ]))
    st_5._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_6, True) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_6, False) ]))
    st_6._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_7, True) ]))
    st_7._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
DQ_TemporalValidity_Type._Automaton = _BuildAutomaton_446()




def _BuildAutomaton_447 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_447
    del _BuildAutomaton_447
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 479, 5))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 480, 5))
    counters.add(cc_1)
    cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 481, 5))
    counters.add(cc_2)
    cc_3 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 482, 5))
    counters.add(cc_3)
    cc_4 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 483, 5))
    counters.add(cc_4)
    cc_5 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 484, 5))
    counters.add(cc_5)
    cc_6 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 485, 5))
    counters.add(cc_6)
    cc_7 = fac.CounterCondition(min=1, max=2, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 486, 5))
    counters.add(cc_7)
    states = []
    final_update = None
    symbol = pyxb.binding.content.ElementUse(DQ_TemporalConsistency_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'nameOfMeasure')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 479, 5))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(DQ_TemporalConsistency_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'measureIdentification')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 480, 5))
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(DQ_TemporalConsistency_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'measureDescription')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 481, 5))
    st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(DQ_TemporalConsistency_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'evaluationMethodType')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 482, 5))
    st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_3)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(DQ_TemporalConsistency_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'evaluationMethodDescription')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 483, 5))
    st_4 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_4)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(DQ_TemporalConsistency_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'evaluationProcedure')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 484, 5))
    st_5 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_5)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(DQ_TemporalConsistency_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'dateTime')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 485, 5))
    st_6 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_6)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_7, False))
    symbol = pyxb.binding.content.ElementUse(DQ_TemporalConsistency_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'result')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 486, 5))
    st_7 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_7)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_1, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_1, False) ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_2, True) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_2, False) ]))
    st_2._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_3, True) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_3, False) ]))
    st_3._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_4, True) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_4, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_4, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_4, False) ]))
    st_4._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_5, True) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_5, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_5, False) ]))
    st_5._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_6, True) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_6, False) ]))
    st_6._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_7, True) ]))
    st_7._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
DQ_TemporalConsistency_Type._Automaton = _BuildAutomaton_447()




def _BuildAutomaton_448 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_448
    del _BuildAutomaton_448
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 479, 5))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 480, 5))
    counters.add(cc_1)
    cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 481, 5))
    counters.add(cc_2)
    cc_3 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 482, 5))
    counters.add(cc_3)
    cc_4 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 483, 5))
    counters.add(cc_4)
    cc_5 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 484, 5))
    counters.add(cc_5)
    cc_6 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 485, 5))
    counters.add(cc_6)
    cc_7 = fac.CounterCondition(min=1, max=2, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 486, 5))
    counters.add(cc_7)
    states = []
    final_update = None
    symbol = pyxb.binding.content.ElementUse(DQ_AccuracyOfATimeMeasurement_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'nameOfMeasure')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 479, 5))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(DQ_AccuracyOfATimeMeasurement_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'measureIdentification')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 480, 5))
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(DQ_AccuracyOfATimeMeasurement_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'measureDescription')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 481, 5))
    st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(DQ_AccuracyOfATimeMeasurement_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'evaluationMethodType')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 482, 5))
    st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_3)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(DQ_AccuracyOfATimeMeasurement_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'evaluationMethodDescription')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 483, 5))
    st_4 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_4)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(DQ_AccuracyOfATimeMeasurement_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'evaluationProcedure')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 484, 5))
    st_5 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_5)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(DQ_AccuracyOfATimeMeasurement_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'dateTime')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 485, 5))
    st_6 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_6)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_7, False))
    symbol = pyxb.binding.content.ElementUse(DQ_AccuracyOfATimeMeasurement_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'result')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 486, 5))
    st_7 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_7)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_1, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_1, False) ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_2, True) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_2, False) ]))
    st_2._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_3, True) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_3, False) ]))
    st_3._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_4, True) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_4, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_4, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_4, False) ]))
    st_4._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_5, True) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_5, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_5, False) ]))
    st_5._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_6, True) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_6, False) ]))
    st_6._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_7, True) ]))
    st_7._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
DQ_AccuracyOfATimeMeasurement_Type._Automaton = _BuildAutomaton_448()




def _BuildAutomaton_449 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_449
    del _BuildAutomaton_449
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 479, 5))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 480, 5))
    counters.add(cc_1)
    cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 481, 5))
    counters.add(cc_2)
    cc_3 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 482, 5))
    counters.add(cc_3)
    cc_4 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 483, 5))
    counters.add(cc_4)
    cc_5 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 484, 5))
    counters.add(cc_5)
    cc_6 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 485, 5))
    counters.add(cc_6)
    cc_7 = fac.CounterCondition(min=1, max=2, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 486, 5))
    counters.add(cc_7)
    states = []
    final_update = None
    symbol = pyxb.binding.content.ElementUse(DQ_QuantitativeAttributeAccuracy_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'nameOfMeasure')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 479, 5))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(DQ_QuantitativeAttributeAccuracy_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'measureIdentification')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 480, 5))
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(DQ_QuantitativeAttributeAccuracy_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'measureDescription')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 481, 5))
    st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(DQ_QuantitativeAttributeAccuracy_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'evaluationMethodType')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 482, 5))
    st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_3)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(DQ_QuantitativeAttributeAccuracy_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'evaluationMethodDescription')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 483, 5))
    st_4 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_4)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(DQ_QuantitativeAttributeAccuracy_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'evaluationProcedure')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 484, 5))
    st_5 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_5)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(DQ_QuantitativeAttributeAccuracy_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'dateTime')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 485, 5))
    st_6 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_6)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_7, False))
    symbol = pyxb.binding.content.ElementUse(DQ_QuantitativeAttributeAccuracy_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'result')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 486, 5))
    st_7 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_7)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_1, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_1, False) ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_2, True) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_2, False) ]))
    st_2._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_3, True) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_3, False) ]))
    st_3._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_4, True) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_4, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_4, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_4, False) ]))
    st_4._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_5, True) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_5, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_5, False) ]))
    st_5._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_6, True) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_6, False) ]))
    st_6._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_7, True) ]))
    st_7._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
DQ_QuantitativeAttributeAccuracy_Type._Automaton = _BuildAutomaton_449()




def _BuildAutomaton_450 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_450
    del _BuildAutomaton_450
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 479, 5))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 480, 5))
    counters.add(cc_1)
    cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 481, 5))
    counters.add(cc_2)
    cc_3 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 482, 5))
    counters.add(cc_3)
    cc_4 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 483, 5))
    counters.add(cc_4)
    cc_5 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 484, 5))
    counters.add(cc_5)
    cc_6 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 485, 5))
    counters.add(cc_6)
    cc_7 = fac.CounterCondition(min=1, max=2, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 486, 5))
    counters.add(cc_7)
    states = []
    final_update = None
    symbol = pyxb.binding.content.ElementUse(DQ_NonQuantitativeAttributeAccuracy_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'nameOfMeasure')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 479, 5))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(DQ_NonQuantitativeAttributeAccuracy_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'measureIdentification')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 480, 5))
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(DQ_NonQuantitativeAttributeAccuracy_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'measureDescription')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 481, 5))
    st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(DQ_NonQuantitativeAttributeAccuracy_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'evaluationMethodType')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 482, 5))
    st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_3)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(DQ_NonQuantitativeAttributeAccuracy_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'evaluationMethodDescription')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 483, 5))
    st_4 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_4)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(DQ_NonQuantitativeAttributeAccuracy_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'evaluationProcedure')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 484, 5))
    st_5 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_5)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(DQ_NonQuantitativeAttributeAccuracy_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'dateTime')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 485, 5))
    st_6 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_6)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_7, False))
    symbol = pyxb.binding.content.ElementUse(DQ_NonQuantitativeAttributeAccuracy_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'result')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 486, 5))
    st_7 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_7)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_1, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_1, False) ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_2, True) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_2, False) ]))
    st_2._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_3, True) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_3, False) ]))
    st_3._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_4, True) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_4, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_4, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_4, False) ]))
    st_4._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_5, True) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_5, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_5, False) ]))
    st_5._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_6, True) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_6, False) ]))
    st_6._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_7, True) ]))
    st_7._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
DQ_NonQuantitativeAttributeAccuracy_Type._Automaton = _BuildAutomaton_450()




def _BuildAutomaton_451 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_451
    del _BuildAutomaton_451
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 479, 5))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 480, 5))
    counters.add(cc_1)
    cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 481, 5))
    counters.add(cc_2)
    cc_3 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 482, 5))
    counters.add(cc_3)
    cc_4 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 483, 5))
    counters.add(cc_4)
    cc_5 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 484, 5))
    counters.add(cc_5)
    cc_6 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 485, 5))
    counters.add(cc_6)
    cc_7 = fac.CounterCondition(min=1, max=2, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 486, 5))
    counters.add(cc_7)
    states = []
    final_update = None
    symbol = pyxb.binding.content.ElementUse(DQ_ThematicClassificationCorrectness_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'nameOfMeasure')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 479, 5))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(DQ_ThematicClassificationCorrectness_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'measureIdentification')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 480, 5))
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(DQ_ThematicClassificationCorrectness_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'measureDescription')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 481, 5))
    st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(DQ_ThematicClassificationCorrectness_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'evaluationMethodType')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 482, 5))
    st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_3)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(DQ_ThematicClassificationCorrectness_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'evaluationMethodDescription')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 483, 5))
    st_4 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_4)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(DQ_ThematicClassificationCorrectness_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'evaluationProcedure')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 484, 5))
    st_5 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_5)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(DQ_ThematicClassificationCorrectness_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'dateTime')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 485, 5))
    st_6 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_6)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_7, False))
    symbol = pyxb.binding.content.ElementUse(DQ_ThematicClassificationCorrectness_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'result')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 486, 5))
    st_7 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_7)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_1, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_1, False) ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_2, True) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_2, False) ]))
    st_2._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_3, True) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_3, False) ]))
    st_3._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_4, True) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_4, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_4, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_4, False) ]))
    st_4._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_5, True) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_5, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_5, False) ]))
    st_5._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_6, True) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_6, False) ]))
    st_6._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_7, True) ]))
    st_7._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
DQ_ThematicClassificationCorrectness_Type._Automaton = _BuildAutomaton_451()




def _BuildAutomaton_452 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_452
    del _BuildAutomaton_452
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 479, 5))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 480, 5))
    counters.add(cc_1)
    cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 481, 5))
    counters.add(cc_2)
    cc_3 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 482, 5))
    counters.add(cc_3)
    cc_4 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 483, 5))
    counters.add(cc_4)
    cc_5 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 484, 5))
    counters.add(cc_5)
    cc_6 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 485, 5))
    counters.add(cc_6)
    cc_7 = fac.CounterCondition(min=1, max=2, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 486, 5))
    counters.add(cc_7)
    states = []
    final_update = None
    symbol = pyxb.binding.content.ElementUse(DQ_RelativeInternalPositionalAccuracy_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'nameOfMeasure')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 479, 5))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(DQ_RelativeInternalPositionalAccuracy_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'measureIdentification')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 480, 5))
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(DQ_RelativeInternalPositionalAccuracy_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'measureDescription')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 481, 5))
    st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(DQ_RelativeInternalPositionalAccuracy_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'evaluationMethodType')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 482, 5))
    st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_3)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(DQ_RelativeInternalPositionalAccuracy_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'evaluationMethodDescription')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 483, 5))
    st_4 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_4)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(DQ_RelativeInternalPositionalAccuracy_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'evaluationProcedure')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 484, 5))
    st_5 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_5)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(DQ_RelativeInternalPositionalAccuracy_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'dateTime')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 485, 5))
    st_6 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_6)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_7, False))
    symbol = pyxb.binding.content.ElementUse(DQ_RelativeInternalPositionalAccuracy_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'result')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 486, 5))
    st_7 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_7)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_1, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_1, False) ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_2, True) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_2, False) ]))
    st_2._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_3, True) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_3, False) ]))
    st_3._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_4, True) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_4, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_4, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_4, False) ]))
    st_4._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_5, True) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_5, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_5, False) ]))
    st_5._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_6, True) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_6, False) ]))
    st_6._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_7, True) ]))
    st_7._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
DQ_RelativeInternalPositionalAccuracy_Type._Automaton = _BuildAutomaton_452()




def _BuildAutomaton_453 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_453
    del _BuildAutomaton_453
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 479, 5))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 480, 5))
    counters.add(cc_1)
    cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 481, 5))
    counters.add(cc_2)
    cc_3 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 482, 5))
    counters.add(cc_3)
    cc_4 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 483, 5))
    counters.add(cc_4)
    cc_5 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 484, 5))
    counters.add(cc_5)
    cc_6 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 485, 5))
    counters.add(cc_6)
    cc_7 = fac.CounterCondition(min=1, max=2, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 486, 5))
    counters.add(cc_7)
    states = []
    final_update = None
    symbol = pyxb.binding.content.ElementUse(DQ_GriddedDataPositionalAccuracy_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'nameOfMeasure')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 479, 5))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(DQ_GriddedDataPositionalAccuracy_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'measureIdentification')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 480, 5))
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(DQ_GriddedDataPositionalAccuracy_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'measureDescription')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 481, 5))
    st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(DQ_GriddedDataPositionalAccuracy_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'evaluationMethodType')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 482, 5))
    st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_3)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(DQ_GriddedDataPositionalAccuracy_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'evaluationMethodDescription')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 483, 5))
    st_4 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_4)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(DQ_GriddedDataPositionalAccuracy_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'evaluationProcedure')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 484, 5))
    st_5 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_5)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(DQ_GriddedDataPositionalAccuracy_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'dateTime')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 485, 5))
    st_6 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_6)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_7, False))
    symbol = pyxb.binding.content.ElementUse(DQ_GriddedDataPositionalAccuracy_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'result')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 486, 5))
    st_7 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_7)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_1, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_1, False) ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_2, True) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_2, False) ]))
    st_2._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_3, True) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_3, False) ]))
    st_3._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_4, True) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_4, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_4, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_4, False) ]))
    st_4._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_5, True) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_5, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_5, False) ]))
    st_5._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_6, True) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_6, False) ]))
    st_6._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_7, True) ]))
    st_7._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
DQ_GriddedDataPositionalAccuracy_Type._Automaton = _BuildAutomaton_453()




def _BuildAutomaton_454 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_454
    del _BuildAutomaton_454
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 479, 5))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 480, 5))
    counters.add(cc_1)
    cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 481, 5))
    counters.add(cc_2)
    cc_3 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 482, 5))
    counters.add(cc_3)
    cc_4 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 483, 5))
    counters.add(cc_4)
    cc_5 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 484, 5))
    counters.add(cc_5)
    cc_6 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 485, 5))
    counters.add(cc_6)
    cc_7 = fac.CounterCondition(min=1, max=2, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 486, 5))
    counters.add(cc_7)
    states = []
    final_update = None
    symbol = pyxb.binding.content.ElementUse(DQ_AbsoluteExternalPositionalAccuracy_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'nameOfMeasure')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 479, 5))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(DQ_AbsoluteExternalPositionalAccuracy_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'measureIdentification')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 480, 5))
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(DQ_AbsoluteExternalPositionalAccuracy_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'measureDescription')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 481, 5))
    st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(DQ_AbsoluteExternalPositionalAccuracy_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'evaluationMethodType')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 482, 5))
    st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_3)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(DQ_AbsoluteExternalPositionalAccuracy_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'evaluationMethodDescription')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 483, 5))
    st_4 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_4)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(DQ_AbsoluteExternalPositionalAccuracy_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'evaluationProcedure')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 484, 5))
    st_5 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_5)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(DQ_AbsoluteExternalPositionalAccuracy_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'dateTime')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 485, 5))
    st_6 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_6)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_7, False))
    symbol = pyxb.binding.content.ElementUse(DQ_AbsoluteExternalPositionalAccuracy_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'result')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 486, 5))
    st_7 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_7)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_1, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_1, False) ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_2, True) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_2, False) ]))
    st_2._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_3, True) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_3, False) ]))
    st_3._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_4, True) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_4, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_4, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_4, False) ]))
    st_4._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_5, True) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_5, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_5, False) ]))
    st_5._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_6, True) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_6, False) ]))
    st_6._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_7, True) ]))
    st_7._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
DQ_AbsoluteExternalPositionalAccuracy_Type._Automaton = _BuildAutomaton_454()




def _BuildAutomaton_455 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_455
    del _BuildAutomaton_455
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 479, 5))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 480, 5))
    counters.add(cc_1)
    cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 481, 5))
    counters.add(cc_2)
    cc_3 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 482, 5))
    counters.add(cc_3)
    cc_4 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 483, 5))
    counters.add(cc_4)
    cc_5 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 484, 5))
    counters.add(cc_5)
    cc_6 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 485, 5))
    counters.add(cc_6)
    cc_7 = fac.CounterCondition(min=1, max=2, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 486, 5))
    counters.add(cc_7)
    states = []
    final_update = None
    symbol = pyxb.binding.content.ElementUse(DQ_TopologicalConsistency_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'nameOfMeasure')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 479, 5))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(DQ_TopologicalConsistency_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'measureIdentification')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 480, 5))
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(DQ_TopologicalConsistency_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'measureDescription')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 481, 5))
    st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(DQ_TopologicalConsistency_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'evaluationMethodType')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 482, 5))
    st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_3)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(DQ_TopologicalConsistency_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'evaluationMethodDescription')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 483, 5))
    st_4 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_4)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(DQ_TopologicalConsistency_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'evaluationProcedure')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 484, 5))
    st_5 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_5)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(DQ_TopologicalConsistency_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'dateTime')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 485, 5))
    st_6 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_6)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_7, False))
    symbol = pyxb.binding.content.ElementUse(DQ_TopologicalConsistency_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'result')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 486, 5))
    st_7 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_7)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_1, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_1, False) ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_2, True) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_2, False) ]))
    st_2._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_3, True) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_3, False) ]))
    st_3._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_4, True) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_4, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_4, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_4, False) ]))
    st_4._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_5, True) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_5, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_5, False) ]))
    st_5._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_6, True) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_6, False) ]))
    st_6._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_7, True) ]))
    st_7._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
DQ_TopologicalConsistency_Type._Automaton = _BuildAutomaton_455()




def _BuildAutomaton_456 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_456
    del _BuildAutomaton_456
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 479, 5))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 480, 5))
    counters.add(cc_1)
    cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 481, 5))
    counters.add(cc_2)
    cc_3 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 482, 5))
    counters.add(cc_3)
    cc_4 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 483, 5))
    counters.add(cc_4)
    cc_5 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 484, 5))
    counters.add(cc_5)
    cc_6 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 485, 5))
    counters.add(cc_6)
    cc_7 = fac.CounterCondition(min=1, max=2, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 486, 5))
    counters.add(cc_7)
    states = []
    final_update = None
    symbol = pyxb.binding.content.ElementUse(DQ_FormatConsistency_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'nameOfMeasure')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 479, 5))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(DQ_FormatConsistency_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'measureIdentification')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 480, 5))
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(DQ_FormatConsistency_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'measureDescription')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 481, 5))
    st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(DQ_FormatConsistency_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'evaluationMethodType')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 482, 5))
    st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_3)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(DQ_FormatConsistency_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'evaluationMethodDescription')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 483, 5))
    st_4 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_4)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(DQ_FormatConsistency_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'evaluationProcedure')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 484, 5))
    st_5 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_5)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(DQ_FormatConsistency_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'dateTime')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 485, 5))
    st_6 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_6)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_7, False))
    symbol = pyxb.binding.content.ElementUse(DQ_FormatConsistency_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'result')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 486, 5))
    st_7 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_7)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_1, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_1, False) ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_2, True) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_2, False) ]))
    st_2._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_3, True) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_3, False) ]))
    st_3._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_4, True) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_4, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_4, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_4, False) ]))
    st_4._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_5, True) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_5, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_5, False) ]))
    st_5._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_6, True) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_6, False) ]))
    st_6._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_7, True) ]))
    st_7._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
DQ_FormatConsistency_Type._Automaton = _BuildAutomaton_456()




def _BuildAutomaton_457 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_457
    del _BuildAutomaton_457
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 479, 5))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 480, 5))
    counters.add(cc_1)
    cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 481, 5))
    counters.add(cc_2)
    cc_3 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 482, 5))
    counters.add(cc_3)
    cc_4 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 483, 5))
    counters.add(cc_4)
    cc_5 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 484, 5))
    counters.add(cc_5)
    cc_6 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 485, 5))
    counters.add(cc_6)
    cc_7 = fac.CounterCondition(min=1, max=2, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 486, 5))
    counters.add(cc_7)
    states = []
    final_update = None
    symbol = pyxb.binding.content.ElementUse(DQ_DomainConsistency_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'nameOfMeasure')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 479, 5))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(DQ_DomainConsistency_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'measureIdentification')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 480, 5))
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(DQ_DomainConsistency_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'measureDescription')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 481, 5))
    st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(DQ_DomainConsistency_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'evaluationMethodType')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 482, 5))
    st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_3)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(DQ_DomainConsistency_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'evaluationMethodDescription')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 483, 5))
    st_4 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_4)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(DQ_DomainConsistency_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'evaluationProcedure')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 484, 5))
    st_5 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_5)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(DQ_DomainConsistency_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'dateTime')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 485, 5))
    st_6 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_6)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_7, False))
    symbol = pyxb.binding.content.ElementUse(DQ_DomainConsistency_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'result')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 486, 5))
    st_7 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_7)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_1, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_1, False) ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_2, True) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_2, False) ]))
    st_2._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_3, True) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_3, False) ]))
    st_3._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_4, True) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_4, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_4, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_4, False) ]))
    st_4._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_5, True) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_5, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_5, False) ]))
    st_5._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_6, True) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_6, False) ]))
    st_6._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_7, True) ]))
    st_7._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
DQ_DomainConsistency_Type._Automaton = _BuildAutomaton_457()




def _BuildAutomaton_458 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_458
    del _BuildAutomaton_458
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 479, 5))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 480, 5))
    counters.add(cc_1)
    cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 481, 5))
    counters.add(cc_2)
    cc_3 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 482, 5))
    counters.add(cc_3)
    cc_4 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 483, 5))
    counters.add(cc_4)
    cc_5 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 484, 5))
    counters.add(cc_5)
    cc_6 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 485, 5))
    counters.add(cc_6)
    cc_7 = fac.CounterCondition(min=1, max=2, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 486, 5))
    counters.add(cc_7)
    states = []
    final_update = None
    symbol = pyxb.binding.content.ElementUse(DQ_ConceptualConsistency_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'nameOfMeasure')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 479, 5))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(DQ_ConceptualConsistency_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'measureIdentification')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 480, 5))
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(DQ_ConceptualConsistency_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'measureDescription')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 481, 5))
    st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(DQ_ConceptualConsistency_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'evaluationMethodType')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 482, 5))
    st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_3)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(DQ_ConceptualConsistency_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'evaluationMethodDescription')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 483, 5))
    st_4 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_4)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(DQ_ConceptualConsistency_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'evaluationProcedure')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 484, 5))
    st_5 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_5)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(DQ_ConceptualConsistency_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'dateTime')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 485, 5))
    st_6 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_6)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_7, False))
    symbol = pyxb.binding.content.ElementUse(DQ_ConceptualConsistency_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'result')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 486, 5))
    st_7 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_7)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_1, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_1, False) ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_2, True) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_2, False) ]))
    st_2._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_3, True) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_3, False) ]))
    st_3._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_4, True) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_4, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_4, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_4, False) ]))
    st_4._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_5, True) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_5, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_5, False) ]))
    st_5._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_6, True) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_6, False) ]))
    st_6._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_7, True) ]))
    st_7._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
DQ_ConceptualConsistency_Type._Automaton = _BuildAutomaton_458()




def _BuildAutomaton_459 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_459
    del _BuildAutomaton_459
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 479, 5))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 480, 5))
    counters.add(cc_1)
    cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 481, 5))
    counters.add(cc_2)
    cc_3 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 482, 5))
    counters.add(cc_3)
    cc_4 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 483, 5))
    counters.add(cc_4)
    cc_5 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 484, 5))
    counters.add(cc_5)
    cc_6 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 485, 5))
    counters.add(cc_6)
    cc_7 = fac.CounterCondition(min=1, max=2, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 486, 5))
    counters.add(cc_7)
    states = []
    final_update = None
    symbol = pyxb.binding.content.ElementUse(DQ_CompletenessOmission_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'nameOfMeasure')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 479, 5))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(DQ_CompletenessOmission_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'measureIdentification')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 480, 5))
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(DQ_CompletenessOmission_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'measureDescription')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 481, 5))
    st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(DQ_CompletenessOmission_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'evaluationMethodType')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 482, 5))
    st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_3)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(DQ_CompletenessOmission_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'evaluationMethodDescription')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 483, 5))
    st_4 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_4)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(DQ_CompletenessOmission_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'evaluationProcedure')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 484, 5))
    st_5 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_5)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(DQ_CompletenessOmission_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'dateTime')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 485, 5))
    st_6 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_6)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_7, False))
    symbol = pyxb.binding.content.ElementUse(DQ_CompletenessOmission_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'result')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 486, 5))
    st_7 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_7)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_1, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_1, False) ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_2, True) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_2, False) ]))
    st_2._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_3, True) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_3, False) ]))
    st_3._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_4, True) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_4, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_4, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_4, False) ]))
    st_4._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_5, True) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_5, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_5, False) ]))
    st_5._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_6, True) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_6, False) ]))
    st_6._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_7, True) ]))
    st_7._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
DQ_CompletenessOmission_Type._Automaton = _BuildAutomaton_459()




def _BuildAutomaton_460 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_460
    del _BuildAutomaton_460
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 479, 5))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 480, 5))
    counters.add(cc_1)
    cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 481, 5))
    counters.add(cc_2)
    cc_3 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 482, 5))
    counters.add(cc_3)
    cc_4 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 483, 5))
    counters.add(cc_4)
    cc_5 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 484, 5))
    counters.add(cc_5)
    cc_6 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 485, 5))
    counters.add(cc_6)
    cc_7 = fac.CounterCondition(min=1, max=2, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 486, 5))
    counters.add(cc_7)
    states = []
    final_update = None
    symbol = pyxb.binding.content.ElementUse(DQ_CompletenessCommission_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'nameOfMeasure')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 479, 5))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(DQ_CompletenessCommission_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'measureIdentification')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 480, 5))
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(DQ_CompletenessCommission_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'measureDescription')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 481, 5))
    st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(DQ_CompletenessCommission_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'evaluationMethodType')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 482, 5))
    st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_3)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(DQ_CompletenessCommission_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'evaluationMethodDescription')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 483, 5))
    st_4 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_4)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(DQ_CompletenessCommission_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'evaluationProcedure')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 484, 5))
    st_5 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_5)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(DQ_CompletenessCommission_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'dateTime')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 485, 5))
    st_6 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_6)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_7, False))
    symbol = pyxb.binding.content.ElementUse(DQ_CompletenessCommission_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'result')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/dataQuality.xsd', 486, 5))
    st_7 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_7)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_1, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_1, False) ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_2, True) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_2, False) ]))
    st_2._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_3, True) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_3, False) ]))
    st_3._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_4, True) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_4, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_4, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_4, False) ]))
    st_4._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_5, True) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_5, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_5, False) ]))
    st_5._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_6, True) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_6, False) ]))
    st_6._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_7, True) ]))
    st_7._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
DQ_CompletenessCommission_Type._Automaton = _BuildAutomaton_460()




PT_FreeText_PropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'PT_FreeText'), PT_FreeText_Type, scope=PT_FreeText_PropertyType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/freeText.xsd', 24, 1)))

def _BuildAutomaton_461 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_461
    del _BuildAutomaton_461
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 166, 2))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/freeText.xsd', 29, 4))
    counters.add(cc_1)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(PT_FreeText_PropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gco, 'CharacterString')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gco/basicTypes.xsd', 167, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_1, False))
    symbol = pyxb.binding.content.ElementUse(PT_FreeText_PropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'PT_FreeText')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/freeText.xsd', 30, 5))
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_1, True) ]))
    st_1._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
PT_FreeText_PropertyType._Automaton = _BuildAutomaton_461()




LocalisedCharacterString_PropertyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'LocalisedCharacterString'), LocalisedCharacterString_Type, scope=LocalisedCharacterString_PropertyType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/freeText.xsd', 67, 1)))

def _BuildAutomaton_462 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_462
    del _BuildAutomaton_462
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/freeText.xsd', 72, 4))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(LocalisedCharacterString_PropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'LocalisedCharacterString')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/freeText.xsd', 73, 5))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
LocalisedCharacterString_PropertyType._Automaton = _BuildAutomaton_462()




def _BuildAutomaton_463 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_463
    del _BuildAutomaton_463
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataApplication.xsd', 23, 5))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataApplication.xsd', 24, 5))
    counters.add(cc_1)
    states = []
    final_update = None
    symbol = pyxb.binding.content.ElementUse(DS_Platform_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'composedOf')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataApplication.xsd', 21, 5))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(DS_Platform_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'seriesMetadata')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataApplication.xsd', 22, 5))
    st_1 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(DS_Platform_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'subset')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataApplication.xsd', 23, 5))
    st_2 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_1, False))
    symbol = pyxb.binding.content.ElementUse(DS_Platform_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'superset')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataApplication.xsd', 24, 5))
    st_3 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_3)
    transitions = []
    transitions.append(fac.Transition(st_0, [
         ]))
    transitions.append(fac.Transition(st_1, [
         ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_1, [
         ]))
    transitions.append(fac.Transition(st_2, [
         ]))
    transitions.append(fac.Transition(st_3, [
         ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_2._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_1, True) ]))
    st_3._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
DS_Platform_Type._Automaton = _BuildAutomaton_463()




def _BuildAutomaton_464 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_464
    del _BuildAutomaton_464
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataApplication.xsd', 23, 5))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataApplication.xsd', 24, 5))
    counters.add(cc_1)
    states = []
    final_update = None
    symbol = pyxb.binding.content.ElementUse(DS_Sensor_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'composedOf')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataApplication.xsd', 21, 5))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(DS_Sensor_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'seriesMetadata')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataApplication.xsd', 22, 5))
    st_1 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(DS_Sensor_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'subset')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataApplication.xsd', 23, 5))
    st_2 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_1, False))
    symbol = pyxb.binding.content.ElementUse(DS_Sensor_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'superset')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataApplication.xsd', 24, 5))
    st_3 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_3)
    transitions = []
    transitions.append(fac.Transition(st_0, [
         ]))
    transitions.append(fac.Transition(st_1, [
         ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_1, [
         ]))
    transitions.append(fac.Transition(st_2, [
         ]))
    transitions.append(fac.Transition(st_3, [
         ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_2._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_1, True) ]))
    st_3._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
DS_Sensor_Type._Automaton = _BuildAutomaton_464()




def _BuildAutomaton_465 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_465
    del _BuildAutomaton_465
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataApplication.xsd', 23, 5))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataApplication.xsd', 24, 5))
    counters.add(cc_1)
    states = []
    final_update = None
    symbol = pyxb.binding.content.ElementUse(DS_ProductionSeries_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'composedOf')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataApplication.xsd', 21, 5))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(DS_ProductionSeries_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'seriesMetadata')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataApplication.xsd', 22, 5))
    st_1 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(DS_ProductionSeries_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'subset')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataApplication.xsd', 23, 5))
    st_2 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_1, False))
    symbol = pyxb.binding.content.ElementUse(DS_ProductionSeries_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'superset')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataApplication.xsd', 24, 5))
    st_3 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_3)
    transitions = []
    transitions.append(fac.Transition(st_0, [
         ]))
    transitions.append(fac.Transition(st_1, [
         ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_1, [
         ]))
    transitions.append(fac.Transition(st_2, [
         ]))
    transitions.append(fac.Transition(st_3, [
         ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_2._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_1, True) ]))
    st_3._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
DS_ProductionSeries_Type._Automaton = _BuildAutomaton_465()




def _BuildAutomaton_466 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_466
    del _BuildAutomaton_466
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataApplication.xsd', 23, 5))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataApplication.xsd', 24, 5))
    counters.add(cc_1)
    states = []
    final_update = None
    symbol = pyxb.binding.content.ElementUse(DS_StereoMate_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'composedOf')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataApplication.xsd', 21, 5))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(DS_StereoMate_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'seriesMetadata')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataApplication.xsd', 22, 5))
    st_1 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(DS_StereoMate_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'subset')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataApplication.xsd', 23, 5))
    st_2 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_1, False))
    symbol = pyxb.binding.content.ElementUse(DS_StereoMate_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'superset')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/metadataApplication.xsd', 24, 5))
    st_3 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_3)
    transitions = []
    transitions.append(fac.Transition(st_0, [
         ]))
    transitions.append(fac.Transition(st_1, [
         ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_1, [
         ]))
    transitions.append(fac.Transition(st_2, [
         ]))
    transitions.append(fac.Transition(st_3, [
         ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_2._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_1, True) ]))
    st_3._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
DS_StereoMate_Type._Automaton = _BuildAutomaton_466()




MD_Georeferenceable_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'controlPointAvailability'), Boolean_PropertyType, scope=MD_Georeferenceable_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/spatialRepresentation.xsd', 90, 5)))

MD_Georeferenceable_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'orientationParameterAvailability'), Boolean_PropertyType, scope=MD_Georeferenceable_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/spatialRepresentation.xsd', 91, 5)))

MD_Georeferenceable_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'orientationParameterDescription'), CharacterString_PropertyType, scope=MD_Georeferenceable_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/spatialRepresentation.xsd', 92, 5)))

MD_Georeferenceable_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'georeferencedParameters'), Record_PropertyType, scope=MD_Georeferenceable_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/spatialRepresentation.xsd', 93, 5)))

MD_Georeferenceable_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'parameterCitation'), CI_Citation_PropertyType, scope=MD_Georeferenceable_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/spatialRepresentation.xsd', 94, 5)))

def _BuildAutomaton_467 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_467
    del _BuildAutomaton_467
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/spatialRepresentation.xsd', 23, 5))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/spatialRepresentation.xsd', 92, 5))
    counters.add(cc_1)
    cc_2 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/spatialRepresentation.xsd', 94, 5))
    counters.add(cc_2)
    states = []
    final_update = None
    symbol = pyxb.binding.content.ElementUse(MD_Georeferenceable_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'numberOfDimensions')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/spatialRepresentation.xsd', 22, 5))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(MD_Georeferenceable_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'axisDimensionProperties')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/spatialRepresentation.xsd', 23, 5))
    st_1 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(MD_Georeferenceable_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'cellGeometry')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/spatialRepresentation.xsd', 24, 5))
    st_2 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(MD_Georeferenceable_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'transformationParameterAvailability')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/spatialRepresentation.xsd', 25, 5))
    st_3 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_3)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(MD_Georeferenceable_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'controlPointAvailability')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/spatialRepresentation.xsd', 90, 5))
    st_4 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_4)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(MD_Georeferenceable_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'orientationParameterAvailability')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/spatialRepresentation.xsd', 91, 5))
    st_5 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_5)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(MD_Georeferenceable_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'orientationParameterDescription')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/spatialRepresentation.xsd', 92, 5))
    st_6 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_6)
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(MD_Georeferenceable_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'georeferencedParameters')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/spatialRepresentation.xsd', 93, 5))
    st_7 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_7)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_2, False))
    symbol = pyxb.binding.content.ElementUse(MD_Georeferenceable_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'parameterCitation')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/spatialRepresentation.xsd', 94, 5))
    st_8 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_8)
    transitions = []
    transitions.append(fac.Transition(st_1, [
         ]))
    transitions.append(fac.Transition(st_2, [
         ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_3, [
         ]))
    st_2._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
         ]))
    st_3._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_5, [
         ]))
    st_4._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_6, [
         ]))
    transitions.append(fac.Transition(st_7, [
         ]))
    st_5._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_1, True) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_1, False) ]))
    st_6._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_8, [
         ]))
    st_7._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_8, [
        fac.UpdateInstruction(cc_2, True) ]))
    st_8._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
MD_Georeferenceable_Type._Automaton = _BuildAutomaton_467()




MD_Georectified_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'checkPointAvailability'), Boolean_PropertyType, scope=MD_Georectified_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/spatialRepresentation.xsd', 136, 5)))

MD_Georectified_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'checkPointDescription'), CharacterString_PropertyType, scope=MD_Georectified_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/spatialRepresentation.xsd', 137, 5)))

MD_Georectified_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'cornerPoints'), GM_Point_PropertyType, scope=MD_Georectified_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/spatialRepresentation.xsd', 138, 5)))

MD_Georectified_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'centerPoint'), GM_Point_PropertyType, scope=MD_Georectified_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/spatialRepresentation.xsd', 139, 5)))

MD_Georectified_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'pointInPixel'), MD_PixelOrientationCode_PropertyType, scope=MD_Georectified_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/spatialRepresentation.xsd', 140, 5)))

MD_Georectified_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'transformationDimensionDescription'), CharacterString_PropertyType, scope=MD_Georectified_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/spatialRepresentation.xsd', 141, 5)))

MD_Georectified_Type._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gmd, 'transformationDimensionMapping'), CharacterString_PropertyType, scope=MD_Georectified_Type, location=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/spatialRepresentation.xsd', 142, 5)))

def _BuildAutomaton_468 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_468
    del _BuildAutomaton_468
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/spatialRepresentation.xsd', 23, 5))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/spatialRepresentation.xsd', 137, 5))
    counters.add(cc_1)
    cc_2 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/spatialRepresentation.xsd', 138, 5))
    counters.add(cc_2)
    cc_3 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/spatialRepresentation.xsd', 139, 5))
    counters.add(cc_3)
    cc_4 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/spatialRepresentation.xsd', 141, 5))
    counters.add(cc_4)
    cc_5 = fac.CounterCondition(min=0, max=2, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/spatialRepresentation.xsd', 142, 5))
    counters.add(cc_5)
    states = []
    final_update = None
    symbol = pyxb.binding.content.ElementUse(MD_Georectified_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'numberOfDimensions')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/spatialRepresentation.xsd', 22, 5))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(MD_Georectified_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'axisDimensionProperties')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/spatialRepresentation.xsd', 23, 5))
    st_1 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(MD_Georectified_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'cellGeometry')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/spatialRepresentation.xsd', 24, 5))
    st_2 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(MD_Georectified_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'transformationParameterAvailability')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/spatialRepresentation.xsd', 25, 5))
    st_3 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_3)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(MD_Georectified_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'checkPointAvailability')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/spatialRepresentation.xsd', 136, 5))
    st_4 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_4)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(MD_Georectified_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'checkPointDescription')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/spatialRepresentation.xsd', 137, 5))
    st_5 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_5)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(MD_Georectified_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'cornerPoints')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/spatialRepresentation.xsd', 138, 5))
    st_6 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_6)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(MD_Georectified_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'centerPoint')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/spatialRepresentation.xsd', 139, 5))
    st_7 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_7)
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(MD_Georectified_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'pointInPixel')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/spatialRepresentation.xsd', 140, 5))
    st_8 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_8)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_4, False))
    symbol = pyxb.binding.content.ElementUse(MD_Georectified_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'transformationDimensionDescription')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/spatialRepresentation.xsd', 141, 5))
    st_9 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_9)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_5, False))
    symbol = pyxb.binding.content.ElementUse(MD_Georectified_Type._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gmd, 'transformationDimensionMapping')), pyxb.utils.utility.Location('http://schemas.opengis.net/iso/19139/20070417/gmd/spatialRepresentation.xsd', 142, 5))
    st_10 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_10)
    transitions = []
    transitions.append(fac.Transition(st_1, [
         ]))
    transitions.append(fac.Transition(st_2, [
         ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_3, [
         ]))
    st_2._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
         ]))
    st_3._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_5, [
         ]))
    transitions.append(fac.Transition(st_6, [
         ]))
    transitions.append(fac.Transition(st_7, [
         ]))
    transitions.append(fac.Transition(st_8, [
         ]))
    st_4._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_1, True) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_8, [
        fac.UpdateInstruction(cc_1, False) ]))
    st_5._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_2, True) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_8, [
        fac.UpdateInstruction(cc_2, False) ]))
    st_6._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_3, True) ]))
    transitions.append(fac.Transition(st_8, [
        fac.UpdateInstruction(cc_3, False) ]))
    st_7._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_9, [
         ]))
    transitions.append(fac.Transition(st_10, [
         ]))
    st_8._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_9, [
        fac.UpdateInstruction(cc_4, True) ]))
    transitions.append(fac.Transition(st_10, [
        fac.UpdateInstruction(cc_4, False) ]))
    st_9._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_10, [
        fac.UpdateInstruction(cc_5, True) ]))
    st_10._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
MD_Georectified_Type._Automaton = _BuildAutomaton_468()




DiscreteCoverageType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'coverageFunction'), CoverageFunctionType, scope=DiscreteCoverageType, documentation='The gml:coverageFunction property describes the mapping function from the domain to the range of the coverage.\nThe value of the CoverageFunction is one of gml:CoverageMappingRule and gml:GridFunction.\nIf the gml:coverageFunction property is omitted for a gridded coverage (including rectified gridded coverages) the gml:startPoint is assumed to be the value of the gml:low property in the gml:Grid geometry, and the gml:sequenceRule is assumed to be linear and the gml:axisOrder property is assumed to be "+1 +2".', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coverage.xsd', 158, 1)))

def _BuildAutomaton_469 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_469
    del _BuildAutomaton_469
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 39, 3))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 40, 3))
    counters.add(cc_1)
    cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 41, 3))
    counters.add(cc_2)
    cc_3 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 42, 3))
    counters.add(cc_3)
    cc_4 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 43, 3))
    counters.add(cc_4)
    cc_5 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/feature.xsd', 26, 5))
    counters.add(cc_5)
    cc_6 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/feature.xsd', 27, 5))
    counters.add(cc_6)
    cc_7 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coverage.xsd', 43, 5))
    counters.add(cc_7)
    states = []
    final_update = None
    symbol = pyxb.binding.content.ElementUse(DiscreteCoverageType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'metaDataProperty')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 39, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(DiscreteCoverageType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'description')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 40, 3))
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(DiscreteCoverageType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'descriptionReference')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 41, 3))
    st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(DiscreteCoverageType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'identifier')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 42, 3))
    st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_3)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(DiscreteCoverageType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'name')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 43, 3))
    st_4 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_4)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(DiscreteCoverageType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'boundedBy')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/feature.xsd', 26, 5))
    st_5 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_5)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(DiscreteCoverageType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'location')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/feature.xsd', 27, 5))
    st_6 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_6)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(DiscreteCoverageType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'domainSet')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coverage.xsd', 28, 5))
    st_7 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_7)
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(DiscreteCoverageType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'rangeSet')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coverage.xsd', 29, 5))
    st_8 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_8)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_7, False))
    symbol = pyxb.binding.content.ElementUse(DiscreteCoverageType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'coverageFunction')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coverage.xsd', 43, 5))
    st_9 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_9)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_1, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_1, False) ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_2, True) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_2, False) ]))
    st_2._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_3, True) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_3, False) ]))
    st_3._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_4, True) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_4, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_4, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_4, False) ]))
    st_4._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_5, True) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_5, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_5, False) ]))
    st_5._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_6, True) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_6, False) ]))
    st_6._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_8, [
         ]))
    st_7._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_9, [
         ]))
    st_8._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_9, [
        fac.UpdateInstruction(cc_7, True) ]))
    st_9._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
DiscreteCoverageType._Automaton = _BuildAutomaton_469()




AbstractContinuousCoverageType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'coverageFunction'), CoverageFunctionType, scope=AbstractContinuousCoverageType, documentation='The gml:coverageFunction property describes the mapping function from the domain to the range of the coverage.\nThe value of the CoverageFunction is one of gml:CoverageMappingRule and gml:GridFunction.\nIf the gml:coverageFunction property is omitted for a gridded coverage (including rectified gridded coverages) the gml:startPoint is assumed to be the value of the gml:low property in the gml:Grid geometry, and the gml:sequenceRule is assumed to be linear and the gml:axisOrder property is assumed to be "+1 +2".', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coverage.xsd', 158, 1)))

def _BuildAutomaton_470 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_470
    del _BuildAutomaton_470
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 39, 3))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 40, 3))
    counters.add(cc_1)
    cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 41, 3))
    counters.add(cc_2)
    cc_3 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 42, 3))
    counters.add(cc_3)
    cc_4 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 43, 3))
    counters.add(cc_4)
    cc_5 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/feature.xsd', 26, 5))
    counters.add(cc_5)
    cc_6 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/feature.xsd', 27, 5))
    counters.add(cc_6)
    cc_7 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coverage.xsd', 58, 5))
    counters.add(cc_7)
    states = []
    final_update = None
    symbol = pyxb.binding.content.ElementUse(AbstractContinuousCoverageType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'metaDataProperty')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 39, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(AbstractContinuousCoverageType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'description')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 40, 3))
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(AbstractContinuousCoverageType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'descriptionReference')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 41, 3))
    st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(AbstractContinuousCoverageType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'identifier')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 42, 3))
    st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_3)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(AbstractContinuousCoverageType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'name')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 43, 3))
    st_4 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_4)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(AbstractContinuousCoverageType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'boundedBy')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/feature.xsd', 26, 5))
    st_5 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_5)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(AbstractContinuousCoverageType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'location')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/feature.xsd', 27, 5))
    st_6 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_6)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(AbstractContinuousCoverageType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'domainSet')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coverage.xsd', 28, 5))
    st_7 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_7)
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(AbstractContinuousCoverageType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'rangeSet')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coverage.xsd', 29, 5))
    st_8 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_8)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_7, False))
    symbol = pyxb.binding.content.ElementUse(AbstractContinuousCoverageType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'coverageFunction')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coverage.xsd', 58, 5))
    st_9 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_9)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_1, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_1, False) ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_2, True) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_2, False) ]))
    st_2._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_3, True) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_3, False) ]))
    st_3._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_4, True) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_4, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_4, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_4, False) ]))
    st_4._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_5, True) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_5, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_5, False) ]))
    st_5._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_6, True) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_6, False) ]))
    st_6._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_8, [
         ]))
    st_7._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_9, [
         ]))
    st_8._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_9, [
        fac.UpdateInstruction(cc_7, True) ]))
    st_9._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
AbstractContinuousCoverageType._Automaton = _BuildAutomaton_470()




def _BuildAutomaton_471 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_471
    del _BuildAutomaton_471
    import pyxb.utils.fac as fac

    counters = set()
    states = []
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(PriorityLocationPropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractGeometry')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 772, 4))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(PriorityLocationPropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'LocationKeyWord')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 773, 4))
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(PriorityLocationPropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'LocationString')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 774, 4))
    st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(PriorityLocationPropertyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'Null')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 775, 4))
    st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_3)
    transitions = []
    st_0._set_transitionSet(transitions)
    transitions = []
    st_1._set_transitionSet(transitions)
    transitions = []
    st_2._set_transitionSet(transitions)
    transitions = []
    st_3._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
PriorityLocationPropertyType._Automaton = _BuildAutomaton_471()




def _BuildAutomaton_472 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_472
    del _BuildAutomaton_472
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 39, 3))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 40, 3))
    counters.add(cc_1)
    cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 41, 3))
    counters.add(cc_2)
    cc_3 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 42, 3))
    counters.add(cc_3)
    cc_4 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 43, 3))
    counters.add(cc_4)
    cc_5 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/feature.xsd', 26, 5))
    counters.add(cc_5)
    cc_6 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/feature.xsd', 27, 5))
    counters.add(cc_6)
    cc_7 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 849, 5))
    counters.add(cc_7)
    cc_8 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 850, 5))
    counters.add(cc_8)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(FeatureCollectionType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'metaDataProperty')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 39, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_1, False))
    symbol = pyxb.binding.content.ElementUse(FeatureCollectionType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'description')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 40, 3))
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_2, False))
    symbol = pyxb.binding.content.ElementUse(FeatureCollectionType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'descriptionReference')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 41, 3))
    st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_3, False))
    symbol = pyxb.binding.content.ElementUse(FeatureCollectionType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'identifier')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 42, 3))
    st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_3)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_4, False))
    symbol = pyxb.binding.content.ElementUse(FeatureCollectionType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'name')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 43, 3))
    st_4 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_4)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_5, False))
    symbol = pyxb.binding.content.ElementUse(FeatureCollectionType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'boundedBy')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/feature.xsd', 26, 5))
    st_5 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_5)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_6, False))
    symbol = pyxb.binding.content.ElementUse(FeatureCollectionType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'location')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/feature.xsd', 27, 5))
    st_6 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_6)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_7, False))
    symbol = pyxb.binding.content.ElementUse(FeatureCollectionType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'featureMember')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 849, 5))
    st_7 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_7)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_8, False))
    symbol = pyxb.binding.content.ElementUse(FeatureCollectionType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'featureMembers')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 850, 5))
    st_8 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_8)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_8, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_1, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_8, [
        fac.UpdateInstruction(cc_1, False) ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_2, True) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_8, [
        fac.UpdateInstruction(cc_2, False) ]))
    st_2._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_3, True) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_8, [
        fac.UpdateInstruction(cc_3, False) ]))
    st_3._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_4, True) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_4, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_4, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_4, False) ]))
    transitions.append(fac.Transition(st_8, [
        fac.UpdateInstruction(cc_4, False) ]))
    st_4._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_5, True) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_5, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_5, False) ]))
    transitions.append(fac.Transition(st_8, [
        fac.UpdateInstruction(cc_5, False) ]))
    st_5._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_6, True) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_6, False) ]))
    transitions.append(fac.Transition(st_8, [
        fac.UpdateInstruction(cc_6, False) ]))
    st_6._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_7, True) ]))
    transitions.append(fac.Transition(st_8, [
        fac.UpdateInstruction(cc_7, False) ]))
    st_7._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_8, [
        fac.UpdateInstruction(cc_8, True) ]))
    st_8._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
FeatureCollectionType._Automaton = _BuildAutomaton_472()




DefinitionProxyType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'definitionRef'), ReferenceType, scope=DefinitionProxyType, documentation='', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 918, 1)))

def _BuildAutomaton_473 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_473
    del _BuildAutomaton_473
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 35, 5))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 36, 5))
    counters.add(cc_1)
    cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 37, 5))
    counters.add(cc_2)
    cc_3 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 39, 5))
    counters.add(cc_3)
    cc_4 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 49, 5))
    counters.add(cc_4)
    states = []
    final_update = None
    symbol = pyxb.binding.content.ElementUse(DefinitionProxyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'metaDataProperty')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 35, 5))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(DefinitionProxyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'description')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 36, 5))
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(DefinitionProxyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'descriptionReference')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 37, 5))
    st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(DefinitionProxyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'identifier')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 38, 5))
    st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_3)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(DefinitionProxyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'name')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 39, 5))
    st_4 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_4)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(DefinitionProxyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'remarks')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 49, 5))
    st_5 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_5)
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(DefinitionProxyType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'definitionRef')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 913, 5))
    st_6 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_6)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_1, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_1, False) ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_2, True) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_2, False) ]))
    st_2._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
         ]))
    transitions.append(fac.Transition(st_5, [
         ]))
    transitions.append(fac.Transition(st_6, [
         ]))
    st_3._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_3, True) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_3, False) ]))
    st_4._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_4, True) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_4, False) ]))
    st_5._set_transitionSet(transitions)
    transitions = []
    st_6._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
DefinitionProxyType._Automaton = _BuildAutomaton_473()




DictionaryType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'indirectEntry'), IndirectEntryType, scope=DictionaryType, documentation='', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 888, 1)))

DictionaryType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'dictionaryEntry'), DictionaryEntryType, scope=DictionaryType, documentation='This property element contains or refers to the definitions which are members of a dictionary. \nThe content model follows the standard GML property pattern, so a gml:dictionaryEntry may either contain or refer to a single gml:Definition. Since gml:Dictionary is substitutable for gml:Definition, the content of an entry may itself be a lower level dictionary. \nNote that if the value is provided by reference, this definition does not carry a handle (gml:id) in this context, so does not allow external references to this specific definition in this context.  When used in this way the referenced definition will usually be in a dictionary in the same XML document.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 73, 1)))

def _BuildAutomaton_474 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_474
    del _BuildAutomaton_474
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 35, 5))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 36, 5))
    counters.add(cc_1)
    cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 37, 5))
    counters.add(cc_2)
    cc_3 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 39, 5))
    counters.add(cc_3)
    cc_4 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 49, 5))
    counters.add(cc_4)
    cc_5 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 65, 4))
    counters.add(cc_5)
    states = []
    final_update = None
    symbol = pyxb.binding.content.ElementUse(DictionaryType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'metaDataProperty')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 35, 5))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(DictionaryType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'description')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 36, 5))
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(DictionaryType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'descriptionReference')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 37, 5))
    st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(DictionaryType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'identifier')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 38, 5))
    st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_3)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_3, False))
    symbol = pyxb.binding.content.ElementUse(DictionaryType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'name')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 39, 5))
    st_4 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_4)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_4, False))
    symbol = pyxb.binding.content.ElementUse(DictionaryType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'remarks')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 49, 5))
    st_5 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_5)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_5, False))
    symbol = pyxb.binding.content.ElementUse(DictionaryType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'dictionaryEntry')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 66, 5))
    st_6 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_6)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_5, False))
    symbol = pyxb.binding.content.ElementUse(DictionaryType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'indirectEntry')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 67, 5))
    st_7 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_7)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_1, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_1, False) ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_2, True) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_2, False) ]))
    st_2._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
         ]))
    transitions.append(fac.Transition(st_5, [
         ]))
    transitions.append(fac.Transition(st_6, [
         ]))
    transitions.append(fac.Transition(st_7, [
         ]))
    st_3._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_3, True) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_3, False) ]))
    st_4._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_4, True) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_4, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_4, False) ]))
    st_5._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_5, True) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_5, True) ]))
    st_6._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_5, True) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_5, True) ]))
    st_7._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
DictionaryType._Automaton = _BuildAutomaton_474()




DynamicFeatureCollectionType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'dynamicMembers'), DynamicFeatureMemberType, scope=DynamicFeatureCollectionType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dynamicFeature.xsd', 67, 1)))

def _BuildAutomaton_475 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_475
    del _BuildAutomaton_475
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 39, 3))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 40, 3))
    counters.add(cc_1)
    cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 41, 3))
    counters.add(cc_2)
    cc_3 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 42, 3))
    counters.add(cc_3)
    cc_4 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 43, 3))
    counters.add(cc_4)
    cc_5 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/feature.xsd', 26, 5))
    counters.add(cc_5)
    cc_6 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/feature.xsd', 27, 5))
    counters.add(cc_6)
    cc_7 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dynamicFeature.xsd', 32, 3))
    counters.add(cc_7)
    cc_8 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dynamicFeature.xsd', 33, 3))
    counters.add(cc_8)
    cc_9 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dynamicFeature.xsd', 34, 3))
    counters.add(cc_9)
    cc_10 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dynamicFeature.xsd', 35, 3))
    counters.add(cc_10)
    states = []
    final_update = None
    symbol = pyxb.binding.content.ElementUse(DynamicFeatureCollectionType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'metaDataProperty')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 39, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(DynamicFeatureCollectionType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'description')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 40, 3))
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(DynamicFeatureCollectionType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'descriptionReference')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 41, 3))
    st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(DynamicFeatureCollectionType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'identifier')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 42, 3))
    st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_3)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(DynamicFeatureCollectionType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'name')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 43, 3))
    st_4 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_4)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(DynamicFeatureCollectionType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'boundedBy')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/feature.xsd', 26, 5))
    st_5 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_5)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(DynamicFeatureCollectionType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'location')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/feature.xsd', 27, 5))
    st_6 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_6)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(DynamicFeatureCollectionType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'validTime')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dynamicFeature.xsd', 32, 3))
    st_7 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_7)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(DynamicFeatureCollectionType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'history')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dynamicFeature.xsd', 33, 3))
    st_8 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_8)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(DynamicFeatureCollectionType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'dataSource')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dynamicFeature.xsd', 34, 3))
    st_9 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_9)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(DynamicFeatureCollectionType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'dataSourceReference')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dynamicFeature.xsd', 35, 3))
    st_10 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_10)
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(DynamicFeatureCollectionType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'dynamicMembers')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dynamicFeature.xsd', 62, 5))
    st_11 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_11)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_8, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_9, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_10, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_11, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_1, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_8, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_9, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_10, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_11, [
        fac.UpdateInstruction(cc_1, False) ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_2, True) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_8, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_9, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_10, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_11, [
        fac.UpdateInstruction(cc_2, False) ]))
    st_2._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_3, True) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_8, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_9, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_10, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_11, [
        fac.UpdateInstruction(cc_3, False) ]))
    st_3._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_4, True) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_4, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_4, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_4, False) ]))
    transitions.append(fac.Transition(st_8, [
        fac.UpdateInstruction(cc_4, False) ]))
    transitions.append(fac.Transition(st_9, [
        fac.UpdateInstruction(cc_4, False) ]))
    transitions.append(fac.Transition(st_10, [
        fac.UpdateInstruction(cc_4, False) ]))
    transitions.append(fac.Transition(st_11, [
        fac.UpdateInstruction(cc_4, False) ]))
    st_4._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_5, True) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_5, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_5, False) ]))
    transitions.append(fac.Transition(st_8, [
        fac.UpdateInstruction(cc_5, False) ]))
    transitions.append(fac.Transition(st_9, [
        fac.UpdateInstruction(cc_5, False) ]))
    transitions.append(fac.Transition(st_10, [
        fac.UpdateInstruction(cc_5, False) ]))
    transitions.append(fac.Transition(st_11, [
        fac.UpdateInstruction(cc_5, False) ]))
    st_5._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_6, True) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_6, False) ]))
    transitions.append(fac.Transition(st_8, [
        fac.UpdateInstruction(cc_6, False) ]))
    transitions.append(fac.Transition(st_9, [
        fac.UpdateInstruction(cc_6, False) ]))
    transitions.append(fac.Transition(st_10, [
        fac.UpdateInstruction(cc_6, False) ]))
    transitions.append(fac.Transition(st_11, [
        fac.UpdateInstruction(cc_6, False) ]))
    st_6._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_7, True) ]))
    transitions.append(fac.Transition(st_8, [
        fac.UpdateInstruction(cc_7, False) ]))
    transitions.append(fac.Transition(st_9, [
        fac.UpdateInstruction(cc_7, False) ]))
    transitions.append(fac.Transition(st_10, [
        fac.UpdateInstruction(cc_7, False) ]))
    transitions.append(fac.Transition(st_11, [
        fac.UpdateInstruction(cc_7, False) ]))
    st_7._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_8, [
        fac.UpdateInstruction(cc_8, True) ]))
    transitions.append(fac.Transition(st_9, [
        fac.UpdateInstruction(cc_8, False) ]))
    transitions.append(fac.Transition(st_10, [
        fac.UpdateInstruction(cc_8, False) ]))
    transitions.append(fac.Transition(st_11, [
        fac.UpdateInstruction(cc_8, False) ]))
    st_8._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_9, [
        fac.UpdateInstruction(cc_9, True) ]))
    transitions.append(fac.Transition(st_10, [
        fac.UpdateInstruction(cc_9, False) ]))
    transitions.append(fac.Transition(st_11, [
        fac.UpdateInstruction(cc_9, False) ]))
    st_9._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_10, [
        fac.UpdateInstruction(cc_10, True) ]))
    transitions.append(fac.Transition(st_11, [
        fac.UpdateInstruction(cc_10, False) ]))
    st_10._set_transitionSet(transitions)
    transitions = []
    st_11._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
DynamicFeatureCollectionType._Automaton = _BuildAutomaton_475()




MultiGeometryType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'geometryMember'), GeometryPropertyType, scope=MultiGeometryType, documentation='This property element either references a geometry element via the XLink-attributes or contains the geometry element.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryAggregates.xsd', 43, 1)))

MultiGeometryType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'geometryMembers'), GeometryArrayPropertyType, scope=MultiGeometryType, documentation='This property element contains a list of geometry elements. The order of the elements is significant and shall be preserved when processing the array.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryAggregates.xsd', 48, 1)))

def _BuildAutomaton_476 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_476
    del _BuildAutomaton_476
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 39, 3))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 40, 3))
    counters.add(cc_1)
    cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 41, 3))
    counters.add(cc_2)
    cc_3 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 42, 3))
    counters.add(cc_3)
    cc_4 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 43, 3))
    counters.add(cc_4)
    cc_5 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryAggregates.xsd', 31, 5))
    counters.add(cc_5)
    cc_6 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryAggregates.xsd', 32, 5))
    counters.add(cc_6)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(MultiGeometryType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'metaDataProperty')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 39, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_1, False))
    symbol = pyxb.binding.content.ElementUse(MultiGeometryType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'description')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 40, 3))
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_2, False))
    symbol = pyxb.binding.content.ElementUse(MultiGeometryType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'descriptionReference')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 41, 3))
    st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_3, False))
    symbol = pyxb.binding.content.ElementUse(MultiGeometryType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'identifier')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 42, 3))
    st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_3)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_4, False))
    symbol = pyxb.binding.content.ElementUse(MultiGeometryType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'name')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 43, 3))
    st_4 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_4)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_5, False))
    symbol = pyxb.binding.content.ElementUse(MultiGeometryType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'geometryMember')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryAggregates.xsd', 31, 5))
    st_5 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_5)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_6, False))
    symbol = pyxb.binding.content.ElementUse(MultiGeometryType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'geometryMembers')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryAggregates.xsd', 32, 5))
    st_6 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_6)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_1, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_1, False) ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_2, True) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_2, False) ]))
    st_2._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_3, True) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_3, False) ]))
    st_3._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_4, True) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_4, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_4, False) ]))
    st_4._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_5, True) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_5, False) ]))
    st_5._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_6, True) ]))
    st_6._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
MultiGeometryType._Automaton = _BuildAutomaton_476()




MultiPointType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'pointMember'), PointPropertyType, scope=MultiPointType, documentation='This property element either references a Point via the XLink-attributes or contains the Point element.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryAggregates.xsd', 79, 1)))

MultiPointType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'pointMembers'), PointArrayPropertyType, scope=MultiPointType, documentation='This property element contains a list of points. The order of the elements is significant and shall be preserved when processing the array.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryAggregates.xsd', 84, 1)))

def _BuildAutomaton_477 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_477
    del _BuildAutomaton_477
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 39, 3))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 40, 3))
    counters.add(cc_1)
    cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 41, 3))
    counters.add(cc_2)
    cc_3 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 42, 3))
    counters.add(cc_3)
    cc_4 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 43, 3))
    counters.add(cc_4)
    cc_5 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryAggregates.xsd', 67, 5))
    counters.add(cc_5)
    cc_6 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryAggregates.xsd', 68, 5))
    counters.add(cc_6)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(MultiPointType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'metaDataProperty')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 39, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_1, False))
    symbol = pyxb.binding.content.ElementUse(MultiPointType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'description')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 40, 3))
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_2, False))
    symbol = pyxb.binding.content.ElementUse(MultiPointType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'descriptionReference')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 41, 3))
    st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_3, False))
    symbol = pyxb.binding.content.ElementUse(MultiPointType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'identifier')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 42, 3))
    st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_3)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_4, False))
    symbol = pyxb.binding.content.ElementUse(MultiPointType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'name')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 43, 3))
    st_4 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_4)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_5, False))
    symbol = pyxb.binding.content.ElementUse(MultiPointType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'pointMember')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryAggregates.xsd', 67, 5))
    st_5 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_5)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_6, False))
    symbol = pyxb.binding.content.ElementUse(MultiPointType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'pointMembers')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryAggregates.xsd', 68, 5))
    st_6 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_6)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_1, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_1, False) ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_2, True) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_2, False) ]))
    st_2._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_3, True) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_3, False) ]))
    st_3._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_4, True) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_4, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_4, False) ]))
    st_4._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_5, True) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_5, False) ]))
    st_5._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_6, True) ]))
    st_6._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
MultiPointType._Automaton = _BuildAutomaton_477()




MultiCurveType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'curveMembers'), CurveArrayPropertyType, scope=MultiCurveType, documentation='This property element contains a list of curves. The order of the elements is significant and shall be preserved when processing the array.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryAggregates.xsd', 115, 1)))

MultiCurveType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'curveMember'), CurvePropertyType, scope=MultiCurveType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 639, 1)))

def _BuildAutomaton_478 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_478
    del _BuildAutomaton_478
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 39, 3))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 40, 3))
    counters.add(cc_1)
    cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 41, 3))
    counters.add(cc_2)
    cc_3 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 42, 3))
    counters.add(cc_3)
    cc_4 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 43, 3))
    counters.add(cc_4)
    cc_5 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryAggregates.xsd', 103, 5))
    counters.add(cc_5)
    cc_6 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryAggregates.xsd', 104, 5))
    counters.add(cc_6)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(MultiCurveType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'metaDataProperty')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 39, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_1, False))
    symbol = pyxb.binding.content.ElementUse(MultiCurveType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'description')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 40, 3))
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_2, False))
    symbol = pyxb.binding.content.ElementUse(MultiCurveType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'descriptionReference')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 41, 3))
    st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_3, False))
    symbol = pyxb.binding.content.ElementUse(MultiCurveType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'identifier')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 42, 3))
    st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_3)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_4, False))
    symbol = pyxb.binding.content.ElementUse(MultiCurveType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'name')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 43, 3))
    st_4 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_4)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_5, False))
    symbol = pyxb.binding.content.ElementUse(MultiCurveType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'curveMember')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryAggregates.xsd', 103, 5))
    st_5 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_5)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_6, False))
    symbol = pyxb.binding.content.ElementUse(MultiCurveType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'curveMembers')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryAggregates.xsd', 104, 5))
    st_6 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_6)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_1, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_1, False) ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_2, True) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_2, False) ]))
    st_2._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_3, True) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_3, False) ]))
    st_3._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_4, True) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_4, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_4, False) ]))
    st_4._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_5, True) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_5, False) ]))
    st_5._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_6, True) ]))
    st_6._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
MultiCurveType._Automaton = _BuildAutomaton_478()




MultiSurfaceType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'surfaceMembers'), SurfaceArrayPropertyType, scope=MultiSurfaceType, documentation='This property element contains a list of surfaces. The order of the elements is significant and shall be preserved when processing the array.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryAggregates.xsd', 146, 1)))

MultiSurfaceType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'surfaceMember'), SurfacePropertyType, scope=MultiSurfaceType, documentation='This property element either references a surface via the XLink-attributes or contains the surface element. A surface element is any element, which is substitutable for gml:AbstractSurface.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 837, 1)))

def _BuildAutomaton_479 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_479
    del _BuildAutomaton_479
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 39, 3))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 40, 3))
    counters.add(cc_1)
    cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 41, 3))
    counters.add(cc_2)
    cc_3 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 42, 3))
    counters.add(cc_3)
    cc_4 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 43, 3))
    counters.add(cc_4)
    cc_5 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryAggregates.xsd', 134, 5))
    counters.add(cc_5)
    cc_6 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryAggregates.xsd', 135, 5))
    counters.add(cc_6)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(MultiSurfaceType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'metaDataProperty')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 39, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_1, False))
    symbol = pyxb.binding.content.ElementUse(MultiSurfaceType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'description')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 40, 3))
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_2, False))
    symbol = pyxb.binding.content.ElementUse(MultiSurfaceType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'descriptionReference')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 41, 3))
    st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_3, False))
    symbol = pyxb.binding.content.ElementUse(MultiSurfaceType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'identifier')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 42, 3))
    st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_3)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_4, False))
    symbol = pyxb.binding.content.ElementUse(MultiSurfaceType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'name')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 43, 3))
    st_4 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_4)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_5, False))
    symbol = pyxb.binding.content.ElementUse(MultiSurfaceType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'surfaceMember')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryAggregates.xsd', 134, 5))
    st_5 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_5)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_6, False))
    symbol = pyxb.binding.content.ElementUse(MultiSurfaceType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'surfaceMembers')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryAggregates.xsd', 135, 5))
    st_6 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_6)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_1, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_1, False) ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_2, True) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_2, False) ]))
    st_2._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_3, True) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_3, False) ]))
    st_3._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_4, True) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_4, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_4, False) ]))
    st_4._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_5, True) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_5, False) ]))
    st_5._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_6, True) ]))
    st_6._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
MultiSurfaceType._Automaton = _BuildAutomaton_479()




MultiSolidType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'solidMember'), SolidPropertyType, scope=MultiSolidType, documentation='This property element either references a solid via the XLink-attributes or contains the solid element. A solid element is any element, which is substitutable for gml:AbstractSolid.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryAggregates.xsd', 177, 1)))

MultiSolidType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'solidMembers'), SolidArrayPropertyType, scope=MultiSolidType, documentation='This property element contains a list of solids. The order of the elements is significant and shall be preserved when processing the array.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryAggregates.xsd', 182, 1)))

def _BuildAutomaton_480 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_480
    del _BuildAutomaton_480
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 39, 3))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 40, 3))
    counters.add(cc_1)
    cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 41, 3))
    counters.add(cc_2)
    cc_3 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 42, 3))
    counters.add(cc_3)
    cc_4 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 43, 3))
    counters.add(cc_4)
    cc_5 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryAggregates.xsd', 165, 5))
    counters.add(cc_5)
    cc_6 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryAggregates.xsd', 166, 5))
    counters.add(cc_6)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(MultiSolidType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'metaDataProperty')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 39, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_1, False))
    symbol = pyxb.binding.content.ElementUse(MultiSolidType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'description')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 40, 3))
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_2, False))
    symbol = pyxb.binding.content.ElementUse(MultiSolidType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'descriptionReference')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 41, 3))
    st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_3, False))
    symbol = pyxb.binding.content.ElementUse(MultiSolidType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'identifier')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 42, 3))
    st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_3)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_4, False))
    symbol = pyxb.binding.content.ElementUse(MultiSolidType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'name')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 43, 3))
    st_4 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_4)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_5, False))
    symbol = pyxb.binding.content.ElementUse(MultiSolidType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'solidMember')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryAggregates.xsd', 165, 5))
    st_5 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_5)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_6, False))
    symbol = pyxb.binding.content.ElementUse(MultiSolidType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'solidMembers')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryAggregates.xsd', 166, 5))
    st_6 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_6)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_1, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_1, False) ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_2, True) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_2, False) ]))
    st_2._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_3, True) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_3, False) ]))
    st_3._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_4, True) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_4, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_4, False) ]))
    st_4._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_5, True) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_5, False) ]))
    st_5._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_6, True) ]))
    st_6._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
MultiSolidType._Automaton = _BuildAutomaton_480()




PointType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'coordinates'), CoordinatesType, scope=PointType, documentation='', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 751, 1)))

PointType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'pos'), DirectPositionType, scope=PointType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic0d1d.xsd', 87, 1)))

def _BuildAutomaton_481 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_481
    del _BuildAutomaton_481
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 39, 3))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 40, 3))
    counters.add(cc_1)
    cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 41, 3))
    counters.add(cc_2)
    cc_3 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 42, 3))
    counters.add(cc_3)
    cc_4 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 43, 3))
    counters.add(cc_4)
    states = []
    final_update = None
    symbol = pyxb.binding.content.ElementUse(PointType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'metaDataProperty')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 39, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(PointType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'description')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 40, 3))
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(PointType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'descriptionReference')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 41, 3))
    st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(PointType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'identifier')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 42, 3))
    st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_3)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(PointType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'name')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 43, 3))
    st_4 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_4)
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(PointType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'pos')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic0d1d.xsd', 182, 6))
    st_5 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_5)
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(PointType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'coordinates')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic0d1d.xsd', 183, 6))
    st_6 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_6)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_1, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_1, False) ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_2, True) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_2, False) ]))
    st_2._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_3, True) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_3, False) ]))
    st_3._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_4, True) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_4, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_4, False) ]))
    st_4._set_transitionSet(transitions)
    transitions = []
    st_5._set_transitionSet(transitions)
    transitions = []
    st_6._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
PointType._Automaton = _BuildAutomaton_481()




def _BuildAutomaton_482 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_482
    del _BuildAutomaton_482
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 39, 3))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 40, 3))
    counters.add(cc_1)
    cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 41, 3))
    counters.add(cc_2)
    cc_3 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 42, 3))
    counters.add(cc_3)
    cc_4 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 43, 3))
    counters.add(cc_4)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(AbstractCurveType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'metaDataProperty')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 39, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_1, False))
    symbol = pyxb.binding.content.ElementUse(AbstractCurveType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'description')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 40, 3))
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_2, False))
    symbol = pyxb.binding.content.ElementUse(AbstractCurveType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'descriptionReference')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 41, 3))
    st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_3, False))
    symbol = pyxb.binding.content.ElementUse(AbstractCurveType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'identifier')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 42, 3))
    st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_3)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_4, False))
    symbol = pyxb.binding.content.ElementUse(AbstractCurveType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'name')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 43, 3))
    st_4 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_4)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_1, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_1, False) ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_2, True) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_2, False) ]))
    st_2._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_3, True) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_3, False) ]))
    st_3._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_4, True) ]))
    st_4._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
AbstractCurveType._Automaton = _BuildAutomaton_482()




def _BuildAutomaton_483 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_483
    del _BuildAutomaton_483
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 39, 3))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 40, 3))
    counters.add(cc_1)
    cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 41, 3))
    counters.add(cc_2)
    cc_3 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 42, 3))
    counters.add(cc_3)
    cc_4 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 43, 3))
    counters.add(cc_4)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(AbstractSurfaceType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'metaDataProperty')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 39, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_1, False))
    symbol = pyxb.binding.content.ElementUse(AbstractSurfaceType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'description')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 40, 3))
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_2, False))
    symbol = pyxb.binding.content.ElementUse(AbstractSurfaceType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'descriptionReference')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 41, 3))
    st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_3, False))
    symbol = pyxb.binding.content.ElementUse(AbstractSurfaceType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'identifier')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 42, 3))
    st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_3)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_4, False))
    symbol = pyxb.binding.content.ElementUse(AbstractSurfaceType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'name')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 43, 3))
    st_4 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_4)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_1, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_1, False) ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_2, True) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_2, False) ]))
    st_2._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_3, True) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_3, False) ]))
    st_3._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_4, True) ]))
    st_4._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
AbstractSurfaceType._Automaton = _BuildAutomaton_483()




def _BuildAutomaton_484 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_484
    del _BuildAutomaton_484
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=3, max=3, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 150, 6))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(CircleType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'pos')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 151, 7))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(CircleType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'pointProperty')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 152, 7))
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(CircleType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'pointRep')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 153, 7))
    st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(CircleType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'posList')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 155, 6))
    st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_3)
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(CircleType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'coordinates')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 156, 6))
    st_4 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_4)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_2._set_transitionSet(transitions)
    transitions = []
    st_3._set_transitionSet(transitions)
    transitions = []
    st_4._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
CircleType._Automaton = _BuildAutomaton_484()




def _BuildAutomaton_485 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_485
    del _BuildAutomaton_485
    import pyxb.utils.fac as fac

    counters = set()
    states = []
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(ConeType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'rows')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 653, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
ConeType._Automaton = _BuildAutomaton_485()




def _BuildAutomaton_486 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_486
    del _BuildAutomaton_486
    import pyxb.utils.fac as fac

    counters = set()
    states = []
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(CylinderType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'rows')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 653, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
CylinderType._Automaton = _BuildAutomaton_486()




def _BuildAutomaton_487 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_487
    del _BuildAutomaton_487
    import pyxb.utils.fac as fac

    counters = set()
    states = []
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(SphereType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'rows')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 653, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
SphereType._Automaton = _BuildAutomaton_487()




def _BuildAutomaton_488 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_488
    del _BuildAutomaton_488
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 39, 3))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 40, 3))
    counters.add(cc_1)
    cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 41, 3))
    counters.add(cc_2)
    cc_3 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 42, 3))
    counters.add(cc_3)
    cc_4 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 43, 3))
    counters.add(cc_4)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(AbstractSolidType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'metaDataProperty')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 39, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_1, False))
    symbol = pyxb.binding.content.ElementUse(AbstractSolidType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'description')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 40, 3))
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_2, False))
    symbol = pyxb.binding.content.ElementUse(AbstractSolidType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'descriptionReference')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 41, 3))
    st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_3, False))
    symbol = pyxb.binding.content.ElementUse(AbstractSolidType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'identifier')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 42, 3))
    st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_3)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_4, False))
    symbol = pyxb.binding.content.ElementUse(AbstractSolidType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'name')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 43, 3))
    st_4 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_4)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_1, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_1, False) ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_2, True) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_2, False) ]))
    st_2._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_3, True) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_3, False) ]))
    st_3._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_4, True) ]))
    st_4._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
AbstractSolidType._Automaton = _BuildAutomaton_488()




RectifiedGridType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'origin'), PointPropertyType, scope=RectifiedGridType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/grids.xsd', 58, 5)))

RectifiedGridType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'offsetVector'), VectorType, scope=RectifiedGridType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/grids.xsd', 59, 5)))

def _BuildAutomaton_489 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_489
    del _BuildAutomaton_489
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 39, 3))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 40, 3))
    counters.add(cc_1)
    cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 41, 3))
    counters.add(cc_2)
    cc_3 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 42, 3))
    counters.add(cc_3)
    cc_4 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 43, 3))
    counters.add(cc_4)
    states = []
    final_update = None
    symbol = pyxb.binding.content.ElementUse(RectifiedGridType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'metaDataProperty')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 39, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(RectifiedGridType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'description')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 40, 3))
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(RectifiedGridType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'descriptionReference')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 41, 3))
    st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(RectifiedGridType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'identifier')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 42, 3))
    st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_3)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(RectifiedGridType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'name')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 43, 3))
    st_4 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_4)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(RectifiedGridType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'limits')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/grids.xsd', 27, 5))
    st_5 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_5)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(RectifiedGridType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'axisLabels')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/grids.xsd', 29, 6))
    st_6 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_6)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(RectifiedGridType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'axisName')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/grids.xsd', 30, 6))
    st_7 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_7)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(RectifiedGridType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'origin')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/grids.xsd', 58, 5))
    st_8 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_8)
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(RectifiedGridType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'offsetVector')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/grids.xsd', 59, 5))
    st_9 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_9)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_1, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_1, False) ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_2, True) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_2, False) ]))
    st_2._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_3, True) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_3, False) ]))
    st_3._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_4, True) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_4, False) ]))
    st_4._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_6, [
         ]))
    transitions.append(fac.Transition(st_7, [
         ]))
    st_5._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_8, [
         ]))
    st_6._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_7, [
         ]))
    transitions.append(fac.Transition(st_8, [
         ]))
    st_7._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_9, [
         ]))
    st_8._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_9, [
         ]))
    st_9._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
RectifiedGridType._Automaton = _BuildAutomaton_489()




DirectedObservationType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'direction'), DirectionPropertyType, scope=DirectedObservationType, documentation='The property gml:direction is intended as a pre-defined property expressing a direction to be assigned to features defined in a GML application schema.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/direction.xsd', 15, 1)))

def _BuildAutomaton_490 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_490
    del _BuildAutomaton_490
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 39, 3))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 40, 3))
    counters.add(cc_1)
    cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 41, 3))
    counters.add(cc_2)
    cc_3 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 42, 3))
    counters.add(cc_3)
    cc_4 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 43, 3))
    counters.add(cc_4)
    cc_5 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/feature.xsd', 26, 5))
    counters.add(cc_5)
    cc_6 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/feature.xsd', 27, 5))
    counters.add(cc_6)
    cc_7 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/observation.xsd', 34, 5))
    counters.add(cc_7)
    cc_8 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/observation.xsd', 35, 5))
    counters.add(cc_8)
    states = []
    final_update = None
    symbol = pyxb.binding.content.ElementUse(DirectedObservationType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'metaDataProperty')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 39, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(DirectedObservationType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'description')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 40, 3))
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(DirectedObservationType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'descriptionReference')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 41, 3))
    st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(DirectedObservationType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'identifier')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 42, 3))
    st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_3)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(DirectedObservationType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'name')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 43, 3))
    st_4 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_4)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(DirectedObservationType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'boundedBy')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/feature.xsd', 26, 5))
    st_5 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_5)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(DirectedObservationType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'location')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/feature.xsd', 27, 5))
    st_6 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_6)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(DirectedObservationType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'validTime')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/observation.xsd', 33, 5))
    st_7 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_7)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(DirectedObservationType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'using')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/observation.xsd', 34, 5))
    st_8 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_8)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(DirectedObservationType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'target')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/observation.xsd', 35, 5))
    st_9 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_9)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(DirectedObservationType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'resultOf')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/observation.xsd', 36, 5))
    st_10 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_10)
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(DirectedObservationType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'direction')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/observation.xsd', 76, 5))
    st_11 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_11)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_1, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_1, False) ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_2, True) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_2, False) ]))
    st_2._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_3, True) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_3, False) ]))
    st_3._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_4, True) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_4, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_4, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_4, False) ]))
    st_4._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_5, True) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_5, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_5, False) ]))
    st_5._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_6, True) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_6, False) ]))
    st_6._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_8, [
         ]))
    transitions.append(fac.Transition(st_9, [
         ]))
    transitions.append(fac.Transition(st_10, [
         ]))
    st_7._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_8, [
        fac.UpdateInstruction(cc_7, True) ]))
    transitions.append(fac.Transition(st_9, [
        fac.UpdateInstruction(cc_7, False) ]))
    transitions.append(fac.Transition(st_10, [
        fac.UpdateInstruction(cc_7, False) ]))
    st_8._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_9, [
        fac.UpdateInstruction(cc_8, True) ]))
    transitions.append(fac.Transition(st_10, [
        fac.UpdateInstruction(cc_8, False) ]))
    st_9._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_11, [
         ]))
    st_10._set_transitionSet(transitions)
    transitions = []
    st_11._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
DirectedObservationType._Automaton = _BuildAutomaton_490()




def _BuildAutomaton_491 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_491
    del _BuildAutomaton_491
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 35, 5))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 36, 5))
    counters.add(cc_1)
    cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 37, 5))
    counters.add(cc_2)
    cc_3 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 39, 5))
    counters.add(cc_3)
    cc_4 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 49, 5))
    counters.add(cc_4)
    states = []
    final_update = None
    symbol = pyxb.binding.content.ElementUse(IdentifiedObjectType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'metaDataProperty')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 35, 5))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(IdentifiedObjectType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'description')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 36, 5))
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(IdentifiedObjectType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'descriptionReference')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 37, 5))
    st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(IdentifiedObjectType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'identifier')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 38, 5))
    st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_3)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_3, False))
    symbol = pyxb.binding.content.ElementUse(IdentifiedObjectType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'name')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 39, 5))
    st_4 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_4)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_4, False))
    symbol = pyxb.binding.content.ElementUse(IdentifiedObjectType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'remarks')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 49, 5))
    st_5 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_5)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_1, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_1, False) ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_2, True) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_2, False) ]))
    st_2._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
         ]))
    transitions.append(fac.Transition(st_5, [
         ]))
    st_3._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_3, True) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_3, False) ]))
    st_4._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_4, True) ]))
    st_5._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
IdentifiedObjectType._Automaton = _BuildAutomaton_491()




def _BuildAutomaton_492 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_492
    del _BuildAutomaton_492
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporal.xsd', 46, 2))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(RelatedTimeType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'AbstractTimePrimitive')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporal.xsd', 47, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
RelatedTimeType._Automaton = _BuildAutomaton_492()




def _BuildAutomaton_493 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_493
    del _BuildAutomaton_493
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 39, 3))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 40, 3))
    counters.add(cc_1)
    cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 41, 3))
    counters.add(cc_2)
    cc_3 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 42, 3))
    counters.add(cc_3)
    cc_4 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 43, 3))
    counters.add(cc_4)
    cc_5 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporal.xsd', 37, 5))
    counters.add(cc_5)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(AbstractTimeGeometricPrimitiveType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'metaDataProperty')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 39, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_1, False))
    symbol = pyxb.binding.content.ElementUse(AbstractTimeGeometricPrimitiveType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'description')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 40, 3))
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_2, False))
    symbol = pyxb.binding.content.ElementUse(AbstractTimeGeometricPrimitiveType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'descriptionReference')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 41, 3))
    st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_3, False))
    symbol = pyxb.binding.content.ElementUse(AbstractTimeGeometricPrimitiveType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'identifier')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 42, 3))
    st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_3)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_4, False))
    symbol = pyxb.binding.content.ElementUse(AbstractTimeGeometricPrimitiveType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'name')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 43, 3))
    st_4 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_4)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_5, False))
    symbol = pyxb.binding.content.ElementUse(AbstractTimeGeometricPrimitiveType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'relatedTime')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporal.xsd', 37, 5))
    st_5 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_5)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_1, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_1, False) ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_2, True) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_2, False) ]))
    st_2._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_3, True) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_3, False) ]))
    st_3._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_4, True) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_4, False) ]))
    st_4._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_5, True) ]))
    st_5._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
AbstractTimeGeometricPrimitiveType._Automaton = _BuildAutomaton_493()




TimeReferenceSystemType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'domainOfValidity'), pyxb.binding.datatypes.string, scope=TimeReferenceSystemType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporalReferenceSystems.xsd', 26, 5)))

def _BuildAutomaton_494 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_494
    del _BuildAutomaton_494
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 35, 5))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 36, 5))
    counters.add(cc_1)
    cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 37, 5))
    counters.add(cc_2)
    cc_3 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 39, 5))
    counters.add(cc_3)
    cc_4 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 49, 5))
    counters.add(cc_4)
    states = []
    final_update = None
    symbol = pyxb.binding.content.ElementUse(TimeReferenceSystemType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'metaDataProperty')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 35, 5))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(TimeReferenceSystemType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'description')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 36, 5))
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(TimeReferenceSystemType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'descriptionReference')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 37, 5))
    st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(TimeReferenceSystemType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'identifier')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 38, 5))
    st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_3)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(TimeReferenceSystemType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'name')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 39, 5))
    st_4 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_4)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(TimeReferenceSystemType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'remarks')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 49, 5))
    st_5 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_5)
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(TimeReferenceSystemType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'domainOfValidity')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporalReferenceSystems.xsd', 26, 5))
    st_6 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_6)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_1, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_1, False) ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_2, True) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_2, False) ]))
    st_2._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
         ]))
    transitions.append(fac.Transition(st_5, [
         ]))
    transitions.append(fac.Transition(st_6, [
         ]))
    st_3._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_3, True) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_3, False) ]))
    st_4._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_4, True) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_4, False) ]))
    st_5._set_transitionSet(transitions)
    transitions = []
    st_6._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
TimeReferenceSystemType._Automaton = _BuildAutomaton_494()




TimeCalendarEraType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'referenceEvent'), StringOrRefType, scope=TimeCalendarEraType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporalReferenceSystems.xsd', 82, 5)))

TimeCalendarEraType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'referenceDate'), CalDate, scope=TimeCalendarEraType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporalReferenceSystems.xsd', 83, 5)))

TimeCalendarEraType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'julianReference'), pyxb.binding.datatypes.decimal, scope=TimeCalendarEraType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporalReferenceSystems.xsd', 84, 5)))

TimeCalendarEraType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'epochOfUse'), TimePeriodPropertyType, scope=TimeCalendarEraType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporalReferenceSystems.xsd', 85, 5)))

def _BuildAutomaton_495 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_495
    del _BuildAutomaton_495
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 35, 5))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 36, 5))
    counters.add(cc_1)
    cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 37, 5))
    counters.add(cc_2)
    cc_3 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 39, 5))
    counters.add(cc_3)
    cc_4 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 49, 5))
    counters.add(cc_4)
    states = []
    final_update = None
    symbol = pyxb.binding.content.ElementUse(TimeCalendarEraType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'metaDataProperty')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 35, 5))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(TimeCalendarEraType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'description')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 36, 5))
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(TimeCalendarEraType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'descriptionReference')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 37, 5))
    st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(TimeCalendarEraType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'identifier')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 38, 5))
    st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_3)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(TimeCalendarEraType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'name')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 39, 5))
    st_4 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_4)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(TimeCalendarEraType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'remarks')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 49, 5))
    st_5 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_5)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(TimeCalendarEraType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'referenceEvent')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporalReferenceSystems.xsd', 82, 5))
    st_6 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_6)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(TimeCalendarEraType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'referenceDate')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporalReferenceSystems.xsd', 83, 5))
    st_7 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_7)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(TimeCalendarEraType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'julianReference')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporalReferenceSystems.xsd', 84, 5))
    st_8 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_8)
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(TimeCalendarEraType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'epochOfUse')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporalReferenceSystems.xsd', 85, 5))
    st_9 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_9)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_1, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_1, False) ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_2, True) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_2, False) ]))
    st_2._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
         ]))
    transitions.append(fac.Transition(st_5, [
         ]))
    transitions.append(fac.Transition(st_6, [
         ]))
    st_3._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_3, True) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_3, False) ]))
    st_4._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_4, True) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_4, False) ]))
    st_5._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_7, [
         ]))
    st_6._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_8, [
         ]))
    st_7._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_9, [
         ]))
    st_8._set_transitionSet(transitions)
    transitions = []
    st_9._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
TimeCalendarEraType._Automaton = _BuildAutomaton_495()




TimeOrdinalEraType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'relatedTime'), RelatedTimeType, scope=TimeOrdinalEraType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporalReferenceSystems.xsd', 169, 5)))

TimeOrdinalEraType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'start'), TimeNodePropertyType, scope=TimeOrdinalEraType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporalReferenceSystems.xsd', 170, 5)))

TimeOrdinalEraType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'end'), TimeNodePropertyType, scope=TimeOrdinalEraType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporalReferenceSystems.xsd', 171, 5)))

TimeOrdinalEraType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'extent'), TimePeriodPropertyType, scope=TimeOrdinalEraType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporalReferenceSystems.xsd', 172, 5)))

TimeOrdinalEraType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'member'), TimeOrdinalEraPropertyType, scope=TimeOrdinalEraType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporalReferenceSystems.xsd', 173, 5)))

TimeOrdinalEraType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'group'), ReferenceType, scope=TimeOrdinalEraType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporalReferenceSystems.xsd', 174, 5)))

def _BuildAutomaton_496 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_496
    del _BuildAutomaton_496
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 35, 5))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 36, 5))
    counters.add(cc_1)
    cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 37, 5))
    counters.add(cc_2)
    cc_3 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 39, 5))
    counters.add(cc_3)
    cc_4 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 49, 5))
    counters.add(cc_4)
    cc_5 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporalReferenceSystems.xsd', 169, 5))
    counters.add(cc_5)
    cc_6 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporalReferenceSystems.xsd', 170, 5))
    counters.add(cc_6)
    cc_7 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporalReferenceSystems.xsd', 171, 5))
    counters.add(cc_7)
    cc_8 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporalReferenceSystems.xsd', 172, 5))
    counters.add(cc_8)
    cc_9 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporalReferenceSystems.xsd', 173, 5))
    counters.add(cc_9)
    cc_10 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporalReferenceSystems.xsd', 174, 5))
    counters.add(cc_10)
    states = []
    final_update = None
    symbol = pyxb.binding.content.ElementUse(TimeOrdinalEraType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'metaDataProperty')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 35, 5))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(TimeOrdinalEraType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'description')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 36, 5))
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(TimeOrdinalEraType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'descriptionReference')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 37, 5))
    st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(TimeOrdinalEraType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'identifier')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 38, 5))
    st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_3)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_3, False))
    symbol = pyxb.binding.content.ElementUse(TimeOrdinalEraType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'name')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 39, 5))
    st_4 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_4)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_4, False))
    symbol = pyxb.binding.content.ElementUse(TimeOrdinalEraType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'remarks')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 49, 5))
    st_5 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_5)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_5, False))
    symbol = pyxb.binding.content.ElementUse(TimeOrdinalEraType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'relatedTime')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporalReferenceSystems.xsd', 169, 5))
    st_6 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_6)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_6, False))
    symbol = pyxb.binding.content.ElementUse(TimeOrdinalEraType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'start')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporalReferenceSystems.xsd', 170, 5))
    st_7 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_7)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_7, False))
    symbol = pyxb.binding.content.ElementUse(TimeOrdinalEraType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'end')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporalReferenceSystems.xsd', 171, 5))
    st_8 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_8)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_8, False))
    symbol = pyxb.binding.content.ElementUse(TimeOrdinalEraType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'extent')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporalReferenceSystems.xsd', 172, 5))
    st_9 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_9)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_9, False))
    symbol = pyxb.binding.content.ElementUse(TimeOrdinalEraType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'member')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporalReferenceSystems.xsd', 173, 5))
    st_10 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_10)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_10, False))
    symbol = pyxb.binding.content.ElementUse(TimeOrdinalEraType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'group')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporalReferenceSystems.xsd', 174, 5))
    st_11 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_11)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_1, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_1, False) ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_2, True) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_2, False) ]))
    st_2._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
         ]))
    transitions.append(fac.Transition(st_5, [
         ]))
    transitions.append(fac.Transition(st_6, [
         ]))
    transitions.append(fac.Transition(st_7, [
         ]))
    transitions.append(fac.Transition(st_8, [
         ]))
    transitions.append(fac.Transition(st_9, [
         ]))
    transitions.append(fac.Transition(st_10, [
         ]))
    transitions.append(fac.Transition(st_11, [
         ]))
    st_3._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_3, True) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_8, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_9, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_10, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_11, [
        fac.UpdateInstruction(cc_3, False) ]))
    st_4._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_4, True) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_4, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_4, False) ]))
    transitions.append(fac.Transition(st_8, [
        fac.UpdateInstruction(cc_4, False) ]))
    transitions.append(fac.Transition(st_9, [
        fac.UpdateInstruction(cc_4, False) ]))
    transitions.append(fac.Transition(st_10, [
        fac.UpdateInstruction(cc_4, False) ]))
    transitions.append(fac.Transition(st_11, [
        fac.UpdateInstruction(cc_4, False) ]))
    st_5._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_5, True) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_5, False) ]))
    transitions.append(fac.Transition(st_8, [
        fac.UpdateInstruction(cc_5, False) ]))
    transitions.append(fac.Transition(st_9, [
        fac.UpdateInstruction(cc_5, False) ]))
    transitions.append(fac.Transition(st_10, [
        fac.UpdateInstruction(cc_5, False) ]))
    transitions.append(fac.Transition(st_11, [
        fac.UpdateInstruction(cc_5, False) ]))
    st_6._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_6, True) ]))
    transitions.append(fac.Transition(st_8, [
        fac.UpdateInstruction(cc_6, False) ]))
    transitions.append(fac.Transition(st_9, [
        fac.UpdateInstruction(cc_6, False) ]))
    transitions.append(fac.Transition(st_10, [
        fac.UpdateInstruction(cc_6, False) ]))
    transitions.append(fac.Transition(st_11, [
        fac.UpdateInstruction(cc_6, False) ]))
    st_7._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_8, [
        fac.UpdateInstruction(cc_7, True) ]))
    transitions.append(fac.Transition(st_9, [
        fac.UpdateInstruction(cc_7, False) ]))
    transitions.append(fac.Transition(st_10, [
        fac.UpdateInstruction(cc_7, False) ]))
    transitions.append(fac.Transition(st_11, [
        fac.UpdateInstruction(cc_7, False) ]))
    st_8._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_9, [
        fac.UpdateInstruction(cc_8, True) ]))
    transitions.append(fac.Transition(st_10, [
        fac.UpdateInstruction(cc_8, False) ]))
    transitions.append(fac.Transition(st_11, [
        fac.UpdateInstruction(cc_8, False) ]))
    st_9._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_10, [
        fac.UpdateInstruction(cc_9, True) ]))
    transitions.append(fac.Transition(st_11, [
        fac.UpdateInstruction(cc_9, False) ]))
    st_10._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_11, [
        fac.UpdateInstruction(cc_10, True) ]))
    st_11._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
TimeOrdinalEraType._Automaton = _BuildAutomaton_496()




AbstractTimeTopologyPrimitiveType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'complex'), ReferenceType, scope=AbstractTimeTopologyPrimitiveType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporalTopology.xsd', 26, 5)))

def _BuildAutomaton_497 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_497
    del _BuildAutomaton_497
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 39, 3))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 40, 3))
    counters.add(cc_1)
    cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 41, 3))
    counters.add(cc_2)
    cc_3 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 42, 3))
    counters.add(cc_3)
    cc_4 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 43, 3))
    counters.add(cc_4)
    cc_5 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporal.xsd', 37, 5))
    counters.add(cc_5)
    cc_6 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporalTopology.xsd', 26, 5))
    counters.add(cc_6)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(AbstractTimeTopologyPrimitiveType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'metaDataProperty')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 39, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_1, False))
    symbol = pyxb.binding.content.ElementUse(AbstractTimeTopologyPrimitiveType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'description')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 40, 3))
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_2, False))
    symbol = pyxb.binding.content.ElementUse(AbstractTimeTopologyPrimitiveType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'descriptionReference')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 41, 3))
    st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_3, False))
    symbol = pyxb.binding.content.ElementUse(AbstractTimeTopologyPrimitiveType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'identifier')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 42, 3))
    st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_3)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_4, False))
    symbol = pyxb.binding.content.ElementUse(AbstractTimeTopologyPrimitiveType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'name')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 43, 3))
    st_4 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_4)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_5, False))
    symbol = pyxb.binding.content.ElementUse(AbstractTimeTopologyPrimitiveType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'relatedTime')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporal.xsd', 37, 5))
    st_5 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_5)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_6, False))
    symbol = pyxb.binding.content.ElementUse(AbstractTimeTopologyPrimitiveType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'complex')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporalTopology.xsd', 26, 5))
    st_6 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_6)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_1, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_1, False) ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_2, True) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_2, False) ]))
    st_2._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_3, True) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_3, False) ]))
    st_3._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_4, True) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_4, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_4, False) ]))
    st_4._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_5, True) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_5, False) ]))
    st_5._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_6, True) ]))
    st_6._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
AbstractTimeTopologyPrimitiveType._Automaton = _BuildAutomaton_497()




TimeTopologyComplexType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'primitive'), TimeTopologyPrimitivePropertyType, scope=TimeTopologyComplexType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporalTopology.xsd', 52, 5)))

def _BuildAutomaton_498 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_498
    del _BuildAutomaton_498
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 39, 3))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 40, 3))
    counters.add(cc_1)
    cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 41, 3))
    counters.add(cc_2)
    cc_3 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 42, 3))
    counters.add(cc_3)
    cc_4 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 43, 3))
    counters.add(cc_4)
    states = []
    final_update = None
    symbol = pyxb.binding.content.ElementUse(TimeTopologyComplexType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'metaDataProperty')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 39, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(TimeTopologyComplexType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'description')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 40, 3))
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(TimeTopologyComplexType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'descriptionReference')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 41, 3))
    st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(TimeTopologyComplexType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'identifier')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 42, 3))
    st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_3)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(TimeTopologyComplexType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'name')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 43, 3))
    st_4 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_4)
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(TimeTopologyComplexType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'primitive')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporalTopology.xsd', 52, 5))
    st_5 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_5)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_1, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_1, False) ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_2, True) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_2, False) ]))
    st_2._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_3, True) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_3, False) ]))
    st_3._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_4, True) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_4, False) ]))
    st_4._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_5, [
         ]))
    st_5._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
TimeTopologyComplexType._Automaton = _BuildAutomaton_498()




NodeType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'pointProperty'), PointPropertyType, scope=NodeType, documentation='This property element either references a point via the XLink-attributes or contains the point element. pointProperty is the predefined property which may be used by GML Application Schemas whenever a GML feature has a property with a value that is substitutable for Point.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic0d1d.xsd', 204, 1)))

NodeType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'container'), FaceOrTopoSolidPropertyType, scope=NodeType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/topology.xsd', 71, 10)))

NodeType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'directedEdge'), DirectedEdgePropertyType, scope=NodeType, documentation='A gml:directedEdge property element describes the boundary of topology faces, the coBoundary of topology nodes and is used in the support of topological line features via the gml:TopoCurve expression, see below. The orientation attribute of type gml:SignType expresses the sense in which the included edge is used, i.e. forward or reverse.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/topology.xsd', 126, 2)))

def _BuildAutomaton_499 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_499
    del _BuildAutomaton_499
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 39, 3))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 40, 3))
    counters.add(cc_1)
    cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 41, 3))
    counters.add(cc_2)
    cc_3 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 42, 3))
    counters.add(cc_3)
    cc_4 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 43, 3))
    counters.add(cc_4)
    cc_5 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/topology.xsd', 71, 10))
    counters.add(cc_5)
    cc_6 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/topology.xsd', 72, 10))
    counters.add(cc_6)
    cc_7 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/topology.xsd', 77, 10))
    counters.add(cc_7)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(NodeType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'metaDataProperty')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 39, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_1, False))
    symbol = pyxb.binding.content.ElementUse(NodeType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'description')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 40, 3))
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_2, False))
    symbol = pyxb.binding.content.ElementUse(NodeType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'descriptionReference')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 41, 3))
    st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_3, False))
    symbol = pyxb.binding.content.ElementUse(NodeType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'identifier')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 42, 3))
    st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_3)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_4, False))
    symbol = pyxb.binding.content.ElementUse(NodeType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'name')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 43, 3))
    st_4 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_4)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_5, False))
    symbol = pyxb.binding.content.ElementUse(NodeType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'container')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/topology.xsd', 71, 10))
    st_5 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_5)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_6, False))
    symbol = pyxb.binding.content.ElementUse(NodeType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'directedEdge')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/topology.xsd', 72, 10))
    st_6 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_6)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_7, False))
    symbol = pyxb.binding.content.ElementUse(NodeType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'pointProperty')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/topology.xsd', 77, 10))
    st_7 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_7)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_1, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_1, False) ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_2, True) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_2, False) ]))
    st_2._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_3, True) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_3, False) ]))
    st_3._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_4, True) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_4, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_4, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_4, False) ]))
    st_4._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_5, True) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_5, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_5, False) ]))
    st_5._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_6, True) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_6, False) ]))
    st_6._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_7, True) ]))
    st_7._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
NodeType._Automaton = _BuildAutomaton_499()




EdgeType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'curveProperty'), CurvePropertyType, scope=EdgeType, documentation='This property element either references a curve via the XLink-attributes or contains the curve element. curveProperty is the predefined property which may be used by GML Application Schemas whenever a GML feature has a property with a value that is substitutable for AbstractCurve.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic0d1d.xsd', 241, 1)))

EdgeType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'directedNode'), DirectedNodePropertyType, scope=EdgeType, documentation='A gml:directedNode property element describes the boundary of topology edges and is used in the support of topological point features via the gml:TopoPoint expression, see below. The orientation attribute of type gml:SignType expresses the sense in which the included node is used: start ("-") or end ("+") node.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/topology.xsd', 91, 2)))

EdgeType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'container'), TopoSolidPropertyType, scope=EdgeType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/topology.xsd', 108, 10)))

EdgeType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'directedFace'), DirectedFacePropertyType, scope=EdgeType, documentation='The gml:directedFace property element describes the boundary of topology solids, in the coBoundary of topology edges and is used in the support of surface features via the gml:TopoSurface expression, see below. The orientation attribute of type gml:SignType expresses the sense in which the included face is used i.e. inward or outward with respect to the surface normal in any geometric realisation.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/topology.xsd', 165, 2)))

def _BuildAutomaton_500 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_500
    del _BuildAutomaton_500
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 39, 3))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 40, 3))
    counters.add(cc_1)
    cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 41, 3))
    counters.add(cc_2)
    cc_3 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 42, 3))
    counters.add(cc_3)
    cc_4 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 43, 3))
    counters.add(cc_4)
    cc_5 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/topology.xsd', 108, 10))
    counters.add(cc_5)
    cc_6 = fac.CounterCondition(min=2, max=2, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/topology.xsd', 109, 10))
    counters.add(cc_6)
    cc_7 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/topology.xsd', 110, 10))
    counters.add(cc_7)
    cc_8 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/topology.xsd', 111, 10))
    counters.add(cc_8)
    states = []
    final_update = None
    symbol = pyxb.binding.content.ElementUse(EdgeType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'metaDataProperty')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 39, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(EdgeType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'description')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 40, 3))
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(EdgeType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'descriptionReference')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 41, 3))
    st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(EdgeType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'identifier')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 42, 3))
    st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_3)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(EdgeType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'name')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 43, 3))
    st_4 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_4)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(EdgeType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'container')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/topology.xsd', 108, 10))
    st_5 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_5)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_6, False))
    symbol = pyxb.binding.content.ElementUse(EdgeType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'directedNode')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/topology.xsd', 109, 10))
    st_6 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_6)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_7, False))
    symbol = pyxb.binding.content.ElementUse(EdgeType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'directedFace')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/topology.xsd', 110, 10))
    st_7 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_7)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_8, False))
    symbol = pyxb.binding.content.ElementUse(EdgeType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'curveProperty')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/topology.xsd', 111, 10))
    st_8 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_8)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_1, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_1, False) ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_2, True) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_2, False) ]))
    st_2._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_3, True) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_3, False) ]))
    st_3._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_4, True) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_4, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_4, False) ]))
    st_4._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_5, True) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_5, False) ]))
    st_5._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_6, True) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_6, False) ]))
    transitions.append(fac.Transition(st_8, [
        fac.UpdateInstruction(cc_6, False) ]))
    st_6._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_7, True) ]))
    transitions.append(fac.Transition(st_8, [
        fac.UpdateInstruction(cc_7, False) ]))
    st_7._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_8, [
        fac.UpdateInstruction(cc_8, True) ]))
    st_8._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
EdgeType._Automaton = _BuildAutomaton_500()




FaceType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'surfaceProperty'), SurfacePropertyType, scope=FaceType, documentation='This property element either references a surface via the XLink-attributes or contains the surface element. surfaceProperty is the predefined property which may be used by GML Application Schemas whenever a GML feature has a property with a value that is substitutable for AbstractSurface.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic2d.xsd', 37, 1)))

FaceType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'directedEdge'), DirectedEdgePropertyType, scope=FaceType, documentation='A gml:directedEdge property element describes the boundary of topology faces, the coBoundary of topology nodes and is used in the support of topological line features via the gml:TopoCurve expression, see below. The orientation attribute of type gml:SignType expresses the sense in which the included edge is used, i.e. forward or reverse.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/topology.xsd', 126, 2)))

FaceType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'isolated'), NodePropertyType, scope=FaceType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/topology.xsd', 143, 10)))

FaceType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'directedTopoSolid'), DirectedTopoSolidPropertyType, scope=FaceType, documentation='The gml:directedSolid property element describes the coBoundary of topology faces and is used in the support of volume features via the gml:TopoVolume expression, see below. The orientation attribute of type gml:SignType expresses the sense in which the included solid appears in the face coboundary. In the context of a gml:TopoVolume the orientation attribute has no meaning.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/topology.xsd', 202, 2)))

def _BuildAutomaton_501 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_501
    del _BuildAutomaton_501
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 39, 3))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 40, 3))
    counters.add(cc_1)
    cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 41, 3))
    counters.add(cc_2)
    cc_3 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 42, 3))
    counters.add(cc_3)
    cc_4 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 43, 3))
    counters.add(cc_4)
    cc_5 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/topology.xsd', 143, 10))
    counters.add(cc_5)
    cc_6 = fac.CounterCondition(min=0, max=2, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/topology.xsd', 145, 10))
    counters.add(cc_6)
    cc_7 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/topology.xsd', 146, 10))
    counters.add(cc_7)
    states = []
    final_update = None
    symbol = pyxb.binding.content.ElementUse(FaceType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'metaDataProperty')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 39, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(FaceType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'description')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 40, 3))
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(FaceType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'descriptionReference')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 41, 3))
    st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(FaceType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'identifier')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 42, 3))
    st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_3)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(FaceType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'name')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 43, 3))
    st_4 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_4)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(FaceType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'isolated')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/topology.xsd', 143, 10))
    st_5 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_5)
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(FaceType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'directedEdge')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/topology.xsd', 144, 10))
    st_6 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_6)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_6, False))
    symbol = pyxb.binding.content.ElementUse(FaceType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'directedTopoSolid')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/topology.xsd', 145, 10))
    st_7 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_7)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_7, False))
    symbol = pyxb.binding.content.ElementUse(FaceType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'surfaceProperty')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/topology.xsd', 146, 10))
    st_8 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_8)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_1, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_1, False) ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_2, True) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_2, False) ]))
    st_2._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_3, True) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_3, False) ]))
    st_3._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_4, True) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_4, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_4, False) ]))
    st_4._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_5, True) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_5, False) ]))
    st_5._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_6, [
         ]))
    transitions.append(fac.Transition(st_7, [
         ]))
    transitions.append(fac.Transition(st_8, [
         ]))
    st_6._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_6, True) ]))
    transitions.append(fac.Transition(st_8, [
        fac.UpdateInstruction(cc_6, False) ]))
    st_7._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_8, [
        fac.UpdateInstruction(cc_7, True) ]))
    st_8._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
FaceType._Automaton = _BuildAutomaton_501()




TopoSolidType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'solidProperty'), SolidPropertyType, scope=TopoSolidType, documentation='This property element either references a solid via the XLink-attributes or contains the solid element. solidProperty is the predefined property which may be used by GML Application Schemas whenever a GML feature has a property with a value that is substitutable for AbstractSolid.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 790, 1)))

TopoSolidType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'directedFace'), DirectedFacePropertyType, scope=TopoSolidType, documentation='The gml:directedFace property element describes the boundary of topology solids, in the coBoundary of topology edges and is used in the support of surface features via the gml:TopoSurface expression, see below. The orientation attribute of type gml:SignType expresses the sense in which the included face is used i.e. inward or outward with respect to the surface normal in any geometric realisation.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/topology.xsd', 165, 2)))

TopoSolidType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'isolated'), NodeOrEdgePropertyType, scope=TopoSolidType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/topology.xsd', 182, 10)))

def _BuildAutomaton_502 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_502
    del _BuildAutomaton_502
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 39, 3))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 40, 3))
    counters.add(cc_1)
    cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 41, 3))
    counters.add(cc_2)
    cc_3 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 42, 3))
    counters.add(cc_3)
    cc_4 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 43, 3))
    counters.add(cc_4)
    cc_5 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/topology.xsd', 182, 10))
    counters.add(cc_5)
    cc_6 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/topology.xsd', 184, 10))
    counters.add(cc_6)
    states = []
    final_update = None
    symbol = pyxb.binding.content.ElementUse(TopoSolidType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'metaDataProperty')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 39, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(TopoSolidType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'description')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 40, 3))
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(TopoSolidType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'descriptionReference')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 41, 3))
    st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(TopoSolidType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'identifier')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 42, 3))
    st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_3)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(TopoSolidType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'name')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 43, 3))
    st_4 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_4)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(TopoSolidType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'isolated')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/topology.xsd', 182, 10))
    st_5 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_5)
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(TopoSolidType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'directedFace')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/topology.xsd', 183, 10))
    st_6 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_6)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_6, False))
    symbol = pyxb.binding.content.ElementUse(TopoSolidType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'solidProperty')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/topology.xsd', 184, 10))
    st_7 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_7)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_1, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_1, False) ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_2, True) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_2, False) ]))
    st_2._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_3, True) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_3, False) ]))
    st_3._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_4, True) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_4, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_4, False) ]))
    st_4._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_5, True) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_5, False) ]))
    st_5._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_6, [
         ]))
    transitions.append(fac.Transition(st_7, [
         ]))
    st_6._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_6, True) ]))
    st_7._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
TopoSolidType._Automaton = _BuildAutomaton_502()




UnitDefinitionType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'quantityType'), StringOrRefType, scope=UnitDefinitionType, documentation='The gml:quantityType property indicates the phenomenon to which the units apply. This element contains an informal description of the phenomenon or type of physical quantity that is measured or observed. When the physical quantity is the result of an observation or measurement, this term is known as observable type or measurand.\nThe use of gml:quantityType for references to remote values is deprecated.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/units.xsd', 48, 1)))

UnitDefinitionType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'quantityTypeReference'), ReferenceType, scope=UnitDefinitionType, documentation='The gml:quantityTypeReference property indicates the phenomenon to which the units apply. The content is a reference to a remote value.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/units.xsd', 54, 1)))

UnitDefinitionType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'catalogSymbol'), CodeType, scope=UnitDefinitionType, documentation='The catalogSymbol is the preferred lexical symbol used for this unit of measure.\nThe codeSpace attribute in gml:CodeType identifies a namespace for the catalog symbol value, and might reference the external catalog. The string value in gml:CodeType contains the value of a symbol that should be unique within this catalog namespace. This symbol often appears explicitly in the catalog, but it could be a combination of symbols using a specified algebra of units.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/units.xsd', 59, 1)))

def _BuildAutomaton_503 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_503
    del _BuildAutomaton_503
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 35, 5))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 36, 5))
    counters.add(cc_1)
    cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 37, 5))
    counters.add(cc_2)
    cc_3 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 39, 5))
    counters.add(cc_3)
    cc_4 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 49, 5))
    counters.add(cc_4)
    cc_5 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/units.xsd', 41, 5))
    counters.add(cc_5)
    cc_6 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/units.xsd', 42, 5))
    counters.add(cc_6)
    cc_7 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/units.xsd', 43, 5))
    counters.add(cc_7)
    states = []
    final_update = None
    symbol = pyxb.binding.content.ElementUse(UnitDefinitionType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'metaDataProperty')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 35, 5))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(UnitDefinitionType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'description')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 36, 5))
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(UnitDefinitionType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'descriptionReference')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 37, 5))
    st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(UnitDefinitionType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'identifier')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 38, 5))
    st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_3)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_3, False))
    symbol = pyxb.binding.content.ElementUse(UnitDefinitionType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'name')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 39, 5))
    st_4 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_4)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_4, False))
    symbol = pyxb.binding.content.ElementUse(UnitDefinitionType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'remarks')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 49, 5))
    st_5 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_5)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_5, False))
    symbol = pyxb.binding.content.ElementUse(UnitDefinitionType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'quantityType')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/units.xsd', 41, 5))
    st_6 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_6)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_6, False))
    symbol = pyxb.binding.content.ElementUse(UnitDefinitionType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'quantityTypeReference')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/units.xsd', 42, 5))
    st_7 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_7)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_7, False))
    symbol = pyxb.binding.content.ElementUse(UnitDefinitionType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'catalogSymbol')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/units.xsd', 43, 5))
    st_8 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_8)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_1, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_1, False) ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_2, True) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_2, False) ]))
    st_2._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
         ]))
    transitions.append(fac.Transition(st_5, [
         ]))
    transitions.append(fac.Transition(st_6, [
         ]))
    transitions.append(fac.Transition(st_7, [
         ]))
    transitions.append(fac.Transition(st_8, [
         ]))
    st_3._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_3, True) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_8, [
        fac.UpdateInstruction(cc_3, False) ]))
    st_4._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_4, True) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_4, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_4, False) ]))
    transitions.append(fac.Transition(st_8, [
        fac.UpdateInstruction(cc_4, False) ]))
    st_5._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_5, True) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_5, False) ]))
    transitions.append(fac.Transition(st_8, [
        fac.UpdateInstruction(cc_5, False) ]))
    st_6._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_6, True) ]))
    transitions.append(fac.Transition(st_8, [
        fac.UpdateInstruction(cc_6, False) ]))
    st_7._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_8, [
        fac.UpdateInstruction(cc_7, True) ]))
    st_8._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
UnitDefinitionType._Automaton = _BuildAutomaton_503()




ConversionToPreferredUnitType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'factor'), pyxb.binding.datatypes.double, scope=ConversionToPreferredUnitType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/units.xsd', 148, 5)))

ConversionToPreferredUnitType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'formula'), FormulaType, scope=ConversionToPreferredUnitType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/units.xsd', 149, 5)))

def _BuildAutomaton_504 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_504
    del _BuildAutomaton_504
    import pyxb.utils.fac as fac

    counters = set()
    states = []
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(ConversionToPreferredUnitType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'factor')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/units.xsd', 148, 5))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(ConversionToPreferredUnitType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'formula')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/units.xsd', 149, 5))
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    transitions = []
    st_0._set_transitionSet(transitions)
    transitions = []
    st_1._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
ConversionToPreferredUnitType._Automaton = _BuildAutomaton_504()




AbstractCoordinateOperationType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'operationVersion'), pyxb.binding.datatypes.string, scope=AbstractCoordinateOperationType, documentation='gml:operationVersion is the version of the coordinate transformation (i.e., instantiation due to the stochastic nature of the parameters). Mandatory when describing a transformation, and should not be supplied for a conversion.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 43, 1)))

AbstractCoordinateOperationType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'coordinateOperationAccuracy'), CTD_ANON_6, scope=AbstractCoordinateOperationType, documentation='gml:coordinateOperationAccuracy is an association role to a DQ_PositionalAccuracy object as encoded in ISO/TS 19139, either referencing or containing the definition of that positional accuracy. That object contains an estimate of the impact of this coordinate operation on point accuracy. That is, it gives position error estimates for the target coordinates of this coordinate operation, assuming no errors in the source coordinates.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 48, 1)))

AbstractCoordinateOperationType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'sourceCRS'), CRSPropertyType, scope=AbstractCoordinateOperationType, documentation='gml:sourceCRS is an association role to the source CRS (coordinate reference system) of this coordinate operation.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 59, 1)))

AbstractCoordinateOperationType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'targetCRS'), CRSPropertyType, scope=AbstractCoordinateOperationType, documentation='gml:targetCRS is an association role to the target CRS (coordinate reference system) of this coordinate operation.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 64, 1)))

AbstractCoordinateOperationType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'domainOfValidity'), CTD_ANON_8, scope=AbstractCoordinateOperationType, documentation='The gml:domainOfValidity property implements an association role to an EX_Extent object as encoded in ISO/TS 19139, either referencing or containing the definition of that extent.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/referenceSystems.xsd', 45, 1)))

AbstractCoordinateOperationType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'scope'), pyxb.binding.datatypes.string, scope=AbstractCoordinateOperationType, documentation='The gml:scope property provides a description of the usage, or limitations of usage, for which this CRS-related object is valid. If unknown, enter "not known".', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/referenceSystems.xsd', 56, 1)))

def _BuildAutomaton_505 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_505
    del _BuildAutomaton_505
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 35, 5))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 36, 5))
    counters.add(cc_1)
    cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 37, 5))
    counters.add(cc_2)
    cc_3 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 39, 5))
    counters.add(cc_3)
    cc_4 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 49, 5))
    counters.add(cc_4)
    cc_5 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 33, 5))
    counters.add(cc_5)
    cc_6 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 35, 5))
    counters.add(cc_6)
    cc_7 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 36, 5))
    counters.add(cc_7)
    cc_8 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 37, 5))
    counters.add(cc_8)
    cc_9 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 38, 5))
    counters.add(cc_9)
    states = []
    final_update = None
    symbol = pyxb.binding.content.ElementUse(AbstractCoordinateOperationType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'metaDataProperty')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 35, 5))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(AbstractCoordinateOperationType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'description')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 36, 5))
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(AbstractCoordinateOperationType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'descriptionReference')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 37, 5))
    st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(AbstractCoordinateOperationType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'identifier')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 38, 5))
    st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_3)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(AbstractCoordinateOperationType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'name')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 39, 5))
    st_4 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_4)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(AbstractCoordinateOperationType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'remarks')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 49, 5))
    st_5 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_5)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(AbstractCoordinateOperationType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'domainOfValidity')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 33, 5))
    st_6 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_6)
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(AbstractCoordinateOperationType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'scope')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 34, 5))
    st_7 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_7)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_6, False))
    symbol = pyxb.binding.content.ElementUse(AbstractCoordinateOperationType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'operationVersion')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 35, 5))
    st_8 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_8)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_7, False))
    symbol = pyxb.binding.content.ElementUse(AbstractCoordinateOperationType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'coordinateOperationAccuracy')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 36, 5))
    st_9 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_9)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_8, False))
    symbol = pyxb.binding.content.ElementUse(AbstractCoordinateOperationType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'sourceCRS')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 37, 5))
    st_10 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_10)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_9, False))
    symbol = pyxb.binding.content.ElementUse(AbstractCoordinateOperationType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'targetCRS')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 38, 5))
    st_11 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_11)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_1, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_1, False) ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_2, True) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_2, False) ]))
    st_2._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
         ]))
    transitions.append(fac.Transition(st_5, [
         ]))
    transitions.append(fac.Transition(st_6, [
         ]))
    transitions.append(fac.Transition(st_7, [
         ]))
    st_3._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_3, True) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_3, False) ]))
    st_4._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_4, True) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_4, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_4, False) ]))
    st_5._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_5, True) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_5, False) ]))
    st_6._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_7, [
         ]))
    transitions.append(fac.Transition(st_8, [
         ]))
    transitions.append(fac.Transition(st_9, [
         ]))
    transitions.append(fac.Transition(st_10, [
         ]))
    transitions.append(fac.Transition(st_11, [
         ]))
    st_7._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_8, [
        fac.UpdateInstruction(cc_6, True) ]))
    transitions.append(fac.Transition(st_9, [
        fac.UpdateInstruction(cc_6, False) ]))
    transitions.append(fac.Transition(st_10, [
        fac.UpdateInstruction(cc_6, False) ]))
    transitions.append(fac.Transition(st_11, [
        fac.UpdateInstruction(cc_6, False) ]))
    st_8._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_9, [
        fac.UpdateInstruction(cc_7, True) ]))
    transitions.append(fac.Transition(st_10, [
        fac.UpdateInstruction(cc_7, False) ]))
    transitions.append(fac.Transition(st_11, [
        fac.UpdateInstruction(cc_7, False) ]))
    st_9._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_10, [
        fac.UpdateInstruction(cc_8, True) ]))
    transitions.append(fac.Transition(st_11, [
        fac.UpdateInstruction(cc_8, False) ]))
    st_10._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_11, [
        fac.UpdateInstruction(cc_9, True) ]))
    st_11._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
AbstractCoordinateOperationType._Automaton = _BuildAutomaton_505()




OperationMethodType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'formulaCitation'), CTD_ANON_7, scope=OperationMethodType, documentation='gml:formulaCitation provides a reference to a publication giving the formula(s) or procedure used by an coordinate operation method.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 406, 1)))

OperationMethodType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'formula'), CodeType, scope=OperationMethodType, documentation='gml:formula Formula(s) or procedure used by an operation method. The use of the codespace attribite has been deprecated. The property value shall be a character string.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 417, 1)))

OperationMethodType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'sourceDimensions'), pyxb.binding.datatypes.positiveInteger, scope=OperationMethodType, documentation='gml:sourceDimensions is the number of dimensions in the source CRS of this operation method.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 422, 1)))

OperationMethodType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'targetDimensions'), pyxb.binding.datatypes.positiveInteger, scope=OperationMethodType, documentation='gml:targetDimensions is the number of dimensions in the target CRS of this operation method.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 427, 1)))

OperationMethodType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'parameter'), AbstractGeneralOperationParameterPropertyType, scope=OperationMethodType, documentation='gml:parameter is an association to an operation parameter or parameter group.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 432, 1)))

def _BuildAutomaton_506 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_506
    del _BuildAutomaton_506
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 35, 5))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 36, 5))
    counters.add(cc_1)
    cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 37, 5))
    counters.add(cc_2)
    cc_3 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 39, 5))
    counters.add(cc_3)
    cc_4 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 49, 5))
    counters.add(cc_4)
    cc_5 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 399, 5))
    counters.add(cc_5)
    cc_6 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 400, 5))
    counters.add(cc_6)
    cc_7 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 401, 5))
    counters.add(cc_7)
    states = []
    final_update = None
    symbol = pyxb.binding.content.ElementUse(OperationMethodType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'metaDataProperty')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 35, 5))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(OperationMethodType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'description')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 36, 5))
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(OperationMethodType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'descriptionReference')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 37, 5))
    st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(OperationMethodType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'identifier')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 38, 5))
    st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_3)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(OperationMethodType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'name')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 39, 5))
    st_4 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_4)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(OperationMethodType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'remarks')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 49, 5))
    st_5 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_5)
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(OperationMethodType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'formulaCitation')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 396, 6))
    st_6 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_6)
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(OperationMethodType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'formula')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 397, 6))
    st_7 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_7)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_5, False))
    symbol = pyxb.binding.content.ElementUse(OperationMethodType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'sourceDimensions')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 399, 5))
    st_8 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_8)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_6, False))
    symbol = pyxb.binding.content.ElementUse(OperationMethodType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'targetDimensions')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 400, 5))
    st_9 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_9)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_7, False))
    symbol = pyxb.binding.content.ElementUse(OperationMethodType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'parameter')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 401, 5))
    st_10 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_10)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_1, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_1, False) ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_2, True) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_2, False) ]))
    st_2._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
         ]))
    transitions.append(fac.Transition(st_5, [
         ]))
    transitions.append(fac.Transition(st_6, [
         ]))
    transitions.append(fac.Transition(st_7, [
         ]))
    st_3._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_3, True) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_3, False) ]))
    st_4._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_4, True) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_4, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_4, False) ]))
    st_5._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_8, [
         ]))
    transitions.append(fac.Transition(st_9, [
         ]))
    transitions.append(fac.Transition(st_10, [
         ]))
    st_6._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_8, [
         ]))
    transitions.append(fac.Transition(st_9, [
         ]))
    transitions.append(fac.Transition(st_10, [
         ]))
    st_7._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_8, [
        fac.UpdateInstruction(cc_5, True) ]))
    transitions.append(fac.Transition(st_9, [
        fac.UpdateInstruction(cc_5, False) ]))
    transitions.append(fac.Transition(st_10, [
        fac.UpdateInstruction(cc_5, False) ]))
    st_8._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_9, [
        fac.UpdateInstruction(cc_6, True) ]))
    transitions.append(fac.Transition(st_10, [
        fac.UpdateInstruction(cc_6, False) ]))
    st_9._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_10, [
        fac.UpdateInstruction(cc_7, True) ]))
    st_10._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
OperationMethodType._Automaton = _BuildAutomaton_506()




AbstractGeneralOperationParameterType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'minimumOccurs'), pyxb.binding.datatypes.nonNegativeInteger, scope=AbstractGeneralOperationParameterType, documentation='gml:minimumOccurs is the minimum number of times that values for this parameter group or parameter are required. If this attribute is omitted, the minimum number shall be one.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 460, 1)))

def _BuildAutomaton_507 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_507
    del _BuildAutomaton_507
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 35, 5))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 36, 5))
    counters.add(cc_1)
    cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 37, 5))
    counters.add(cc_2)
    cc_3 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 39, 5))
    counters.add(cc_3)
    cc_4 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 49, 5))
    counters.add(cc_4)
    cc_5 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 455, 5))
    counters.add(cc_5)
    states = []
    final_update = None
    symbol = pyxb.binding.content.ElementUse(AbstractGeneralOperationParameterType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'metaDataProperty')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 35, 5))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(AbstractGeneralOperationParameterType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'description')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 36, 5))
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(AbstractGeneralOperationParameterType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'descriptionReference')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 37, 5))
    st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(AbstractGeneralOperationParameterType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'identifier')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 38, 5))
    st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_3)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_3, False))
    symbol = pyxb.binding.content.ElementUse(AbstractGeneralOperationParameterType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'name')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 39, 5))
    st_4 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_4)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_4, False))
    symbol = pyxb.binding.content.ElementUse(AbstractGeneralOperationParameterType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'remarks')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 49, 5))
    st_5 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_5)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_5, False))
    symbol = pyxb.binding.content.ElementUse(AbstractGeneralOperationParameterType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'minimumOccurs')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 455, 5))
    st_6 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_6)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_1, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_1, False) ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_2, True) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_2, False) ]))
    st_2._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
         ]))
    transitions.append(fac.Transition(st_5, [
         ]))
    transitions.append(fac.Transition(st_6, [
         ]))
    st_3._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_3, True) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_3, False) ]))
    st_4._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_4, True) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_4, False) ]))
    st_5._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_5, True) ]))
    st_6._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
AbstractGeneralOperationParameterType._Automaton = _BuildAutomaton_507()




CoordinateSystemAxisType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'axisAbbrev'), CodeType, scope=CoordinateSystemAxisType, documentation='gml:axisAbbrev is the abbreviation used for this coordinate system axis; this abbreviation is also used to identify the coordinates in the coordinate tuple. The codeSpace attribute may reference a source of more information on a set of standardized abbreviations, or on this abbreviation.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateSystems.xsd', 42, 1)))

CoordinateSystemAxisType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'axisDirection'), CodeWithAuthorityType, scope=CoordinateSystemAxisType, documentation='gml:axisDirection is the direction of this coordinate system axis (or in the case of Cartesian projected coordinates, the direction of this coordinate system axis at the origin).\nWithin any set of coordinate system axes, only one of each pair of terms may be used. For earth-fixed CRSs, this direction is often approximate and intended to provide a human interpretable meaning to the axis. When a geodetic datum is used, the precise directions of the axes may therefore vary slightly from this approximate direction.\nThe codeSpace attribute shall reference a source of information specifying the values and meanings of all the allowed string values for this property.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateSystems.xsd', 47, 1)))

CoordinateSystemAxisType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'minimumValue'), pyxb.binding.datatypes.double, scope=CoordinateSystemAxisType, documentation='The gml:minimumValue and gml:maximumValue properties allow the specification of minimum and maximum value normally allowed for this axis, in the unit of measure for the axis. For a continuous angular axis such as longitude, the values wrap-around at this value. Also, values beyond this minimum/maximum can be used for specified purposes, such as in a bounding box. A value of minus infinity shall be allowed for the gml:minimumValue element, a value of plus infiniy for the gml:maximumValue element. If these elements are omitted, the value is unspecified.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateSystems.xsd', 54, 1)))

CoordinateSystemAxisType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'maximumValue'), pyxb.binding.datatypes.double, scope=CoordinateSystemAxisType, documentation='The gml:minimumValue and gml:maximumValue properties allow the specification of minimum and maximum value normally allowed for this axis, in the unit of measure for the axis. For a continuous angular axis such as longitude, the values wrap-around at this value. Also, values beyond this minimum/maximum can be used for specified purposes, such as in a bounding box. A value of minus infinity shall be allowed for the gml:minimumValue element, a value of plus infiniy for the gml:maximumValue element. If these elements are omitted, the value is unspecified.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateSystems.xsd', 59, 1)))

CoordinateSystemAxisType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'rangeMeaning'), CodeWithAuthorityType, scope=CoordinateSystemAxisType, documentation='gml:rangeMeaning describes the meaning of axis value range specified by gml:minimumValue and gml:maximumValue. This element shall be omitted when both gml:minimumValue and gml:maximumValue are omitted. This element should be included when gml:minimumValue and/or gml:maximumValue are included. If this element is omitted when the gml:minimumValue and/or gml:maximumValue are included, the meaning is unspecified. The codeSpace attribute shall reference a source of information specifying the values and meanings of all the allowed string values for this property.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateSystems.xsd', 64, 1)))

def _BuildAutomaton_508 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_508
    del _BuildAutomaton_508
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 35, 5))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 36, 5))
    counters.add(cc_1)
    cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 37, 5))
    counters.add(cc_2)
    cc_3 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 39, 5))
    counters.add(cc_3)
    cc_4 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 49, 5))
    counters.add(cc_4)
    cc_5 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateSystems.xsd', 30, 5))
    counters.add(cc_5)
    cc_6 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateSystems.xsd', 31, 5))
    counters.add(cc_6)
    cc_7 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateSystems.xsd', 32, 5))
    counters.add(cc_7)
    states = []
    final_update = None
    symbol = pyxb.binding.content.ElementUse(CoordinateSystemAxisType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'metaDataProperty')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 35, 5))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(CoordinateSystemAxisType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'description')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 36, 5))
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(CoordinateSystemAxisType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'descriptionReference')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 37, 5))
    st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(CoordinateSystemAxisType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'identifier')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 38, 5))
    st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_3)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(CoordinateSystemAxisType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'name')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 39, 5))
    st_4 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_4)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(CoordinateSystemAxisType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'remarks')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 49, 5))
    st_5 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_5)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(CoordinateSystemAxisType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'axisAbbrev')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateSystems.xsd', 28, 5))
    st_6 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_6)
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(CoordinateSystemAxisType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'axisDirection')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateSystems.xsd', 29, 5))
    st_7 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_7)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_5, False))
    symbol = pyxb.binding.content.ElementUse(CoordinateSystemAxisType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'minimumValue')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateSystems.xsd', 30, 5))
    st_8 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_8)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_6, False))
    symbol = pyxb.binding.content.ElementUse(CoordinateSystemAxisType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'maximumValue')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateSystems.xsd', 31, 5))
    st_9 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_9)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_7, False))
    symbol = pyxb.binding.content.ElementUse(CoordinateSystemAxisType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'rangeMeaning')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateSystems.xsd', 32, 5))
    st_10 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_10)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_1, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_1, False) ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_2, True) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_2, False) ]))
    st_2._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
         ]))
    transitions.append(fac.Transition(st_5, [
         ]))
    transitions.append(fac.Transition(st_6, [
         ]))
    st_3._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_3, True) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_3, False) ]))
    st_4._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_4, True) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_4, False) ]))
    st_5._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_7, [
         ]))
    st_6._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_8, [
         ]))
    transitions.append(fac.Transition(st_9, [
         ]))
    transitions.append(fac.Transition(st_10, [
         ]))
    st_7._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_8, [
        fac.UpdateInstruction(cc_5, True) ]))
    transitions.append(fac.Transition(st_9, [
        fac.UpdateInstruction(cc_5, False) ]))
    transitions.append(fac.Transition(st_10, [
        fac.UpdateInstruction(cc_5, False) ]))
    st_8._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_9, [
        fac.UpdateInstruction(cc_6, True) ]))
    transitions.append(fac.Transition(st_10, [
        fac.UpdateInstruction(cc_6, False) ]))
    st_9._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_10, [
        fac.UpdateInstruction(cc_7, True) ]))
    st_10._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
CoordinateSystemAxisType._Automaton = _BuildAutomaton_508()




AbstractCoordinateSystemType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'axis'), CoordinateSystemAxisPropertyType, scope=AbstractCoordinateSystemType, documentation='The gml:axis property is an association role (ordered sequence) to the coordinate system axes included in this coordinate system. The coordinate values in a coordinate tuple shall be recorded in the order in which the coordinate system axes associations are recorded, whenever those coordinates use a coordinate reference system that uses this coordinate system. The gml:AggregationAttributeGroup should be used to specify that the axis objects are ordered.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateSystems.xsd', 93, 1)))

def _BuildAutomaton_509 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_509
    del _BuildAutomaton_509
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 35, 5))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 36, 5))
    counters.add(cc_1)
    cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 37, 5))
    counters.add(cc_2)
    cc_3 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 39, 5))
    counters.add(cc_3)
    cc_4 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 49, 5))
    counters.add(cc_4)
    states = []
    final_update = None
    symbol = pyxb.binding.content.ElementUse(AbstractCoordinateSystemType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'metaDataProperty')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 35, 5))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(AbstractCoordinateSystemType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'description')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 36, 5))
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(AbstractCoordinateSystemType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'descriptionReference')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 37, 5))
    st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(AbstractCoordinateSystemType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'identifier')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 38, 5))
    st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_3)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(AbstractCoordinateSystemType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'name')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 39, 5))
    st_4 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_4)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(AbstractCoordinateSystemType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'remarks')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 49, 5))
    st_5 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_5)
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(AbstractCoordinateSystemType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'axis')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateSystems.xsd', 87, 5))
    st_6 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_6)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_1, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_1, False) ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_2, True) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_2, False) ]))
    st_2._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
         ]))
    transitions.append(fac.Transition(st_5, [
         ]))
    transitions.append(fac.Transition(st_6, [
         ]))
    st_3._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_3, True) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_3, False) ]))
    st_4._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_4, True) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_4, False) ]))
    st_5._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_6, [
         ]))
    st_6._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
AbstractCoordinateSystemType._Automaton = _BuildAutomaton_509()




AbstractDatumType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'anchorDefinition'), CodeType, scope=AbstractDatumType, documentation='gml:anchorDefinition is a description, possibly including coordinates, of the definition used to anchor the datum to the Earth. Also known as the "origin", especially for engineering and image datums. The codeSpace attribute may be used to reference a source of more detailed on this point or surface, or on a set of such descriptions.\n-\tFor a geodetic datum, this point is also known as the fundamental point, which is traditionally the point where the relationship between geoid and ellipsoid is defined. In some cases, the "fundamental point" may consist of a number of points. In those cases, the parameters defining the geoid/ellipsoid relationship have been averaged for these points, and the averages adopted as the datum definition.\n-\tFor an engineering datum, the anchor definition may be a physical point, or it may be a point with defined coordinates in another CRS.may\n-\tFor an image datum, the anchor definition is usually either the centre of the image or the corner of the image.\n-\tFor a temporal datum, this attribute is not defined. Instead of the anchor definition, a temporal datum carries a separate time origin of type DateTime.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/datums.xsd', 38, 1)))

AbstractDatumType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'realizationEpoch'), pyxb.binding.datatypes.date, scope=AbstractDatumType, documentation='gml:realizationEpoch is the time after which this datum definition is valid. See ISO 19111 Table 32 for details.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/datums.xsd', 47, 1)))

AbstractDatumType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'domainOfValidity'), CTD_ANON_8, scope=AbstractDatumType, documentation='The gml:domainOfValidity property implements an association role to an EX_Extent object as encoded in ISO/TS 19139, either referencing or containing the definition of that extent.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/referenceSystems.xsd', 45, 1)))

AbstractDatumType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'scope'), pyxb.binding.datatypes.string, scope=AbstractDatumType, documentation='The gml:scope property provides a description of the usage, or limitations of usage, for which this CRS-related object is valid. If unknown, enter "not known".', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/referenceSystems.xsd', 56, 1)))

def _BuildAutomaton_510 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_510
    del _BuildAutomaton_510
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 35, 5))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 36, 5))
    counters.add(cc_1)
    cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 37, 5))
    counters.add(cc_2)
    cc_3 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 39, 5))
    counters.add(cc_3)
    cc_4 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 49, 5))
    counters.add(cc_4)
    cc_5 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/datums.xsd', 30, 5))
    counters.add(cc_5)
    cc_6 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/datums.xsd', 32, 5))
    counters.add(cc_6)
    cc_7 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/datums.xsd', 33, 5))
    counters.add(cc_7)
    states = []
    final_update = None
    symbol = pyxb.binding.content.ElementUse(AbstractDatumType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'metaDataProperty')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 35, 5))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(AbstractDatumType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'description')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 36, 5))
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(AbstractDatumType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'descriptionReference')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 37, 5))
    st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(AbstractDatumType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'identifier')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 38, 5))
    st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_3)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(AbstractDatumType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'name')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 39, 5))
    st_4 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_4)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(AbstractDatumType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'remarks')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 49, 5))
    st_5 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_5)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(AbstractDatumType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'domainOfValidity')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/datums.xsd', 30, 5))
    st_6 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_6)
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(AbstractDatumType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'scope')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/datums.xsd', 31, 5))
    st_7 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_7)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_6, False))
    symbol = pyxb.binding.content.ElementUse(AbstractDatumType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'anchorDefinition')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/datums.xsd', 32, 5))
    st_8 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_8)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_7, False))
    symbol = pyxb.binding.content.ElementUse(AbstractDatumType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'realizationEpoch')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/datums.xsd', 33, 5))
    st_9 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_9)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_1, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_1, False) ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_2, True) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_2, False) ]))
    st_2._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
         ]))
    transitions.append(fac.Transition(st_5, [
         ]))
    transitions.append(fac.Transition(st_6, [
         ]))
    transitions.append(fac.Transition(st_7, [
         ]))
    st_3._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_3, True) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_3, False) ]))
    st_4._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_4, True) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_4, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_4, False) ]))
    st_5._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_5, True) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_5, False) ]))
    st_6._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_7, [
         ]))
    transitions.append(fac.Transition(st_8, [
         ]))
    transitions.append(fac.Transition(st_9, [
         ]))
    st_7._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_8, [
        fac.UpdateInstruction(cc_6, True) ]))
    transitions.append(fac.Transition(st_9, [
        fac.UpdateInstruction(cc_6, False) ]))
    st_8._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_9, [
        fac.UpdateInstruction(cc_7, True) ]))
    st_9._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
AbstractDatumType._Automaton = _BuildAutomaton_510()




EllipsoidType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'semiMajorAxis'), MeasureType, scope=EllipsoidType, documentation='gml:semiMajorAxis specifies the length of the semi-major axis of the ellipsoid, with its units. Uses the MeasureType with the restriction that the unit of measure referenced by uom must be suitable for a length, such as metres or feet.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/datums.xsd', 110, 1)))

EllipsoidType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'secondDefiningParameter'), CTD_ANON, scope=EllipsoidType, documentation='gml:secondDefiningParameter is a property containing the definition of the second parameter that defines the shape of an ellipsoid. An ellipsoid requires two defining parameters: semi-major axis and inverse flattening or semi-major axis and semi-minor axis. When the reference body is a sphere rather than an ellipsoid, only a single defining parameter is required, namely the radius of the sphere; in that case, the semi-major axis "degenerates" into the radius of the sphere.\nThe inverseFlattening element contains the inverse flattening value of the ellipsoid. This value is a scale factor (or ratio). It uses gml:LengthType with the restriction that the unit of measure referenced by the uom attribute must be suitable for a scale factor, such as percent, permil, or parts-per-million.\nThe semiMinorAxis element contains the length of the semi-minor axis of the ellipsoid. When the isSphere element is included, the ellipsoid is degenerate and is actually a sphere. The sphere is completely defined by the semi-major axis, which is the radius of the sphere.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/datums.xsd', 115, 1)))

def _BuildAutomaton_511 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_511
    del _BuildAutomaton_511
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 35, 5))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 36, 5))
    counters.add(cc_1)
    cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 37, 5))
    counters.add(cc_2)
    cc_3 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 39, 5))
    counters.add(cc_3)
    cc_4 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 49, 5))
    counters.add(cc_4)
    states = []
    final_update = None
    symbol = pyxb.binding.content.ElementUse(EllipsoidType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'metaDataProperty')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 35, 5))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(EllipsoidType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'description')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 36, 5))
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(EllipsoidType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'descriptionReference')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 37, 5))
    st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(EllipsoidType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'identifier')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 38, 5))
    st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_3)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(EllipsoidType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'name')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 39, 5))
    st_4 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_4)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(EllipsoidType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'remarks')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 49, 5))
    st_5 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_5)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(EllipsoidType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'semiMajorAxis')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/datums.xsd', 104, 5))
    st_6 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_6)
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(EllipsoidType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'secondDefiningParameter')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/datums.xsd', 105, 5))
    st_7 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_7)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_1, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_1, False) ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_2, True) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_2, False) ]))
    st_2._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
         ]))
    transitions.append(fac.Transition(st_5, [
         ]))
    transitions.append(fac.Transition(st_6, [
         ]))
    st_3._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_3, True) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_3, False) ]))
    st_4._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_4, True) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_4, False) ]))
    st_5._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_7, [
         ]))
    st_6._set_transitionSet(transitions)
    transitions = []
    st_7._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
EllipsoidType._Automaton = _BuildAutomaton_511()




PrimeMeridianType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'greenwichLongitude'), AngleType, scope=PrimeMeridianType, documentation='gml:greenwichLongitude is the longitude of the prime meridian measured from the Greenwich meridian, positive eastward. If the value of the prime meridian "name" is "Greenwich" then the value of greenwichLongitude shall be 0 degrees.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/datums.xsd', 159, 1)))

def _BuildAutomaton_512 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_512
    del _BuildAutomaton_512
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 35, 5))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 36, 5))
    counters.add(cc_1)
    cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 37, 5))
    counters.add(cc_2)
    cc_3 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 39, 5))
    counters.add(cc_3)
    cc_4 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 49, 5))
    counters.add(cc_4)
    states = []
    final_update = None
    symbol = pyxb.binding.content.ElementUse(PrimeMeridianType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'metaDataProperty')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 35, 5))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(PrimeMeridianType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'description')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 36, 5))
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(PrimeMeridianType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'descriptionReference')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 37, 5))
    st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(PrimeMeridianType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'identifier')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 38, 5))
    st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_3)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(PrimeMeridianType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'name')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 39, 5))
    st_4 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_4)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(PrimeMeridianType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'remarks')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 49, 5))
    st_5 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_5)
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(PrimeMeridianType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'greenwichLongitude')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/datums.xsd', 154, 5))
    st_6 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_6)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_1, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_1, False) ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_2, True) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_2, False) ]))
    st_2._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
         ]))
    transitions.append(fac.Transition(st_5, [
         ]))
    transitions.append(fac.Transition(st_6, [
         ]))
    st_3._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_3, True) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_3, False) ]))
    st_4._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_4, True) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_4, False) ]))
    st_5._set_transitionSet(transitions)
    transitions = []
    st_6._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
PrimeMeridianType._Automaton = _BuildAutomaton_512()




LineStringType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'coordinates'), CoordinatesType, scope=LineStringType, documentation='', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 751, 1)))

LineStringType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'pointRep'), PointPropertyType, scope=LineStringType, documentation='', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 756, 1)))

LineStringType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'pos'), DirectPositionType, scope=LineStringType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic0d1d.xsd', 87, 1)))

LineStringType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'posList'), DirectPositionListType, scope=LineStringType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic0d1d.xsd', 102, 1)))

LineStringType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'pointProperty'), PointPropertyType, scope=LineStringType, documentation='This property element either references a point via the XLink-attributes or contains the point element. pointProperty is the predefined property which may be used by GML Application Schemas whenever a GML feature has a property with a value that is substitutable for Point.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic0d1d.xsd', 204, 1)))

def _BuildAutomaton_513 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_513
    del _BuildAutomaton_513
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 39, 3))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 40, 3))
    counters.add(cc_1)
    cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 41, 3))
    counters.add(cc_2)
    cc_3 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 42, 3))
    counters.add(cc_3)
    cc_4 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 43, 3))
    counters.add(cc_4)
    cc_5 = fac.CounterCondition(min=2, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic0d1d.xsd', 260, 6))
    counters.add(cc_5)
    states = []
    final_update = None
    symbol = pyxb.binding.content.ElementUse(LineStringType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'metaDataProperty')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 39, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(LineStringType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'description')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 40, 3))
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(LineStringType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'descriptionReference')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 41, 3))
    st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(LineStringType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'identifier')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 42, 3))
    st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_3)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(LineStringType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'name')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 43, 3))
    st_4 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_4)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_5, False))
    symbol = pyxb.binding.content.ElementUse(LineStringType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'pos')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic0d1d.xsd', 261, 7))
    st_5 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_5)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_5, False))
    symbol = pyxb.binding.content.ElementUse(LineStringType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'pointProperty')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic0d1d.xsd', 262, 7))
    st_6 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_6)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_5, False))
    symbol = pyxb.binding.content.ElementUse(LineStringType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'pointRep')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic0d1d.xsd', 263, 7))
    st_7 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_7)
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(LineStringType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'posList')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic0d1d.xsd', 265, 6))
    st_8 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_8)
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(LineStringType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'coordinates')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic0d1d.xsd', 266, 6))
    st_9 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_9)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_8, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_9, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_1, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_8, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_9, [
        fac.UpdateInstruction(cc_1, False) ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_2, True) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_8, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_9, [
        fac.UpdateInstruction(cc_2, False) ]))
    st_2._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_3, True) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_8, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_9, [
        fac.UpdateInstruction(cc_3, False) ]))
    st_3._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_4, True) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_4, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_4, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_4, False) ]))
    transitions.append(fac.Transition(st_8, [
        fac.UpdateInstruction(cc_4, False) ]))
    transitions.append(fac.Transition(st_9, [
        fac.UpdateInstruction(cc_4, False) ]))
    st_4._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_5, True) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_5, True) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_5, True) ]))
    st_5._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_5, True) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_5, True) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_5, True) ]))
    st_6._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_5, True) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_5, True) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_5, True) ]))
    st_7._set_transitionSet(transitions)
    transitions = []
    st_8._set_transitionSet(transitions)
    transitions = []
    st_9._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
LineStringType._Automaton = _BuildAutomaton_513()




PolygonType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'exterior'), AbstractRingPropertyType, scope=PolygonType, documentation='A boundary of a surface consists of a number of rings. In the normal 2D case, one of these rings is distinguished as being the exterior boundary. In a general manifold this is not always possible, in which case all boundaries shall be listed as interior boundaries, and the exterior will be empty.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic2d.xsd', 67, 1)))

PolygonType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'interior'), AbstractRingPropertyType, scope=PolygonType, documentation='A boundary of a surface consists of a number of rings. The "interior" rings separate the surface / surface patch from the area enclosed by the rings.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic2d.xsd', 72, 1)))

def _BuildAutomaton_514 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_514
    del _BuildAutomaton_514
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 39, 3))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 40, 3))
    counters.add(cc_1)
    cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 41, 3))
    counters.add(cc_2)
    cc_3 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 42, 3))
    counters.add(cc_3)
    cc_4 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 43, 3))
    counters.add(cc_4)
    cc_5 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic2d.xsd', 55, 5))
    counters.add(cc_5)
    cc_6 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic2d.xsd', 56, 5))
    counters.add(cc_6)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(PolygonType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'metaDataProperty')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 39, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_1, False))
    symbol = pyxb.binding.content.ElementUse(PolygonType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'description')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 40, 3))
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_2, False))
    symbol = pyxb.binding.content.ElementUse(PolygonType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'descriptionReference')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 41, 3))
    st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_3, False))
    symbol = pyxb.binding.content.ElementUse(PolygonType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'identifier')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 42, 3))
    st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_3)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_4, False))
    symbol = pyxb.binding.content.ElementUse(PolygonType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'name')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 43, 3))
    st_4 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_4)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_5, False))
    symbol = pyxb.binding.content.ElementUse(PolygonType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'exterior')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic2d.xsd', 55, 5))
    st_5 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_5)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_6, False))
    symbol = pyxb.binding.content.ElementUse(PolygonType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'interior')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic2d.xsd', 56, 5))
    st_6 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_6)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_1, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_1, False) ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_2, True) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_2, False) ]))
    st_2._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_3, True) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_3, False) ]))
    st_3._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_4, True) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_4, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_4, False) ]))
    st_4._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_5, True) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_5, False) ]))
    st_5._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_6, True) ]))
    st_6._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
PolygonType._Automaton = _BuildAutomaton_514()




def _BuildAutomaton_515 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_515
    del _BuildAutomaton_515
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 39, 3))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 40, 3))
    counters.add(cc_1)
    cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 41, 3))
    counters.add(cc_2)
    cc_3 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 42, 3))
    counters.add(cc_3)
    cc_4 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 43, 3))
    counters.add(cc_4)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(AbstractRingType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'metaDataProperty')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 39, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_1, False))
    symbol = pyxb.binding.content.ElementUse(AbstractRingType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'description')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 40, 3))
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_2, False))
    symbol = pyxb.binding.content.ElementUse(AbstractRingType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'descriptionReference')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 41, 3))
    st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_3, False))
    symbol = pyxb.binding.content.ElementUse(AbstractRingType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'identifier')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 42, 3))
    st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_3)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_4, False))
    symbol = pyxb.binding.content.ElementUse(AbstractRingType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'name')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 43, 3))
    st_4 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_4)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_1, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_1, False) ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_2, True) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_2, False) ]))
    st_2._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_3, True) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_3, False) ]))
    st_3._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_4, True) ]))
    st_4._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
AbstractRingType._Automaton = _BuildAutomaton_515()




CompositeCurveType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'curveMember'), CurvePropertyType, scope=CompositeCurveType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 639, 1)))

def _BuildAutomaton_516 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_516
    del _BuildAutomaton_516
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 39, 3))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 40, 3))
    counters.add(cc_1)
    cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 41, 3))
    counters.add(cc_2)
    cc_3 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 42, 3))
    counters.add(cc_3)
    cc_4 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 43, 3))
    counters.add(cc_4)
    states = []
    final_update = None
    symbol = pyxb.binding.content.ElementUse(CompositeCurveType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'metaDataProperty')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 39, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(CompositeCurveType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'description')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 40, 3))
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(CompositeCurveType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'descriptionReference')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 41, 3))
    st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(CompositeCurveType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'identifier')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 42, 3))
    st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_3)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(CompositeCurveType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'name')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 43, 3))
    st_4 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_4)
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(CompositeCurveType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'curveMember')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryComplexes.xsd', 48, 5))
    st_5 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_5)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_1, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_1, False) ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_2, True) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_2, False) ]))
    st_2._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_3, True) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_3, False) ]))
    st_3._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_4, True) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_4, False) ]))
    st_4._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_5, [
         ]))
    st_5._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
CompositeCurveType._Automaton = _BuildAutomaton_516()




CompositeSurfaceType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'surfaceMember'), SurfacePropertyType, scope=CompositeSurfaceType, documentation='This property element either references a surface via the XLink-attributes or contains the surface element. A surface element is any element, which is substitutable for gml:AbstractSurface.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 837, 1)))

def _BuildAutomaton_517 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_517
    del _BuildAutomaton_517
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 39, 3))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 40, 3))
    counters.add(cc_1)
    cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 41, 3))
    counters.add(cc_2)
    cc_3 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 42, 3))
    counters.add(cc_3)
    cc_4 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 43, 3))
    counters.add(cc_4)
    states = []
    final_update = None
    symbol = pyxb.binding.content.ElementUse(CompositeSurfaceType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'metaDataProperty')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 39, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(CompositeSurfaceType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'description')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 40, 3))
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(CompositeSurfaceType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'descriptionReference')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 41, 3))
    st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(CompositeSurfaceType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'identifier')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 42, 3))
    st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_3)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(CompositeSurfaceType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'name')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 43, 3))
    st_4 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_4)
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(CompositeSurfaceType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'surfaceMember')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryComplexes.xsd', 65, 5))
    st_5 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_5)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_1, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_1, False) ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_2, True) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_2, False) ]))
    st_2._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_3, True) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_3, False) ]))
    st_3._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_4, True) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_4, False) ]))
    st_4._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_5, [
         ]))
    st_5._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
CompositeSurfaceType._Automaton = _BuildAutomaton_517()




CompositeSolidType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'solidMember'), SolidPropertyType, scope=CompositeSolidType, documentation='This property element either references a solid via the XLink-attributes or contains the solid element. A solid element is any element, which is substitutable for gml:AbstractSolid.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryAggregates.xsd', 177, 1)))

def _BuildAutomaton_518 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_518
    del _BuildAutomaton_518
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 39, 3))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 40, 3))
    counters.add(cc_1)
    cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 41, 3))
    counters.add(cc_2)
    cc_3 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 42, 3))
    counters.add(cc_3)
    cc_4 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 43, 3))
    counters.add(cc_4)
    states = []
    final_update = None
    symbol = pyxb.binding.content.ElementUse(CompositeSolidType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'metaDataProperty')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 39, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(CompositeSolidType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'description')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 40, 3))
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(CompositeSolidType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'descriptionReference')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 41, 3))
    st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(CompositeSolidType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'identifier')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 42, 3))
    st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_3)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(CompositeSolidType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'name')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 43, 3))
    st_4 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_4)
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(CompositeSolidType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'solidMember')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryComplexes.xsd', 82, 5))
    st_5 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_5)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_1, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_1, False) ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_2, True) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_2, False) ]))
    st_2._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_3, True) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_3, False) ]))
    st_3._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_4, True) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_4, False) ]))
    st_4._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_5, [
         ]))
    st_5._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
CompositeSolidType._Automaton = _BuildAutomaton_518()




CurveType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'segments'), CurveSegmentArrayPropertyType, scope=CurveType, documentation='This property element contains a list of curve segments. The order of the elements is significant and shall be preserved when processing the array.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 73, 1)))

def _BuildAutomaton_519 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_519
    del _BuildAutomaton_519
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 39, 3))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 40, 3))
    counters.add(cc_1)
    cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 41, 3))
    counters.add(cc_2)
    cc_3 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 42, 3))
    counters.add(cc_3)
    cc_4 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 43, 3))
    counters.add(cc_4)
    states = []
    final_update = None
    symbol = pyxb.binding.content.ElementUse(CurveType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'metaDataProperty')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 39, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(CurveType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'description')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 40, 3))
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(CurveType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'descriptionReference')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 41, 3))
    st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(CurveType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'identifier')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 42, 3))
    st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_3)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(CurveType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'name')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 43, 3))
    st_4 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_4)
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(CurveType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'segments')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 19, 5))
    st_5 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_5)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_1, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_1, False) ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_2, True) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_2, False) ]))
    st_2._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_3, True) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_3, False) ]))
    st_3._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_4, True) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_4, False) ]))
    st_4._set_transitionSet(transitions)
    transitions = []
    st_5._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
CurveType._Automaton = _BuildAutomaton_519()




OrientableCurveType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'baseCurve'), CurvePropertyType, scope=OrientableCurveType, documentation='The property baseCurve references or contains the base curve, i.e. it either references the base curve via the XLink-attributes or contains the curve element. A curve element is any element which is substitutable for AbstractCurve. The base curve has positive orientation.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 42, 1)))

def _BuildAutomaton_520 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_520
    del _BuildAutomaton_520
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 39, 3))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 40, 3))
    counters.add(cc_1)
    cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 41, 3))
    counters.add(cc_2)
    cc_3 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 42, 3))
    counters.add(cc_3)
    cc_4 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 43, 3))
    counters.add(cc_4)
    states = []
    final_update = None
    symbol = pyxb.binding.content.ElementUse(OrientableCurveType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'metaDataProperty')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 39, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(OrientableCurveType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'description')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 40, 3))
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(OrientableCurveType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'descriptionReference')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 41, 3))
    st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(OrientableCurveType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'identifier')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 42, 3))
    st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_3)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(OrientableCurveType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'name')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 43, 3))
    st_4 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_4)
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(OrientableCurveType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'baseCurve')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 36, 5))
    st_5 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_5)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_1, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_1, False) ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_2, True) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_2, False) ]))
    st_2._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_3, True) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_3, False) ]))
    st_3._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_4, True) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_4, False) ]))
    st_4._set_transitionSet(transitions)
    transitions = []
    st_5._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
OrientableCurveType._Automaton = _BuildAutomaton_520()




SurfaceType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'patches'), SurfacePatchArrayPropertyType, scope=SurfaceType, documentation='The patches property element contains the sequence of surface patches. The order of the elements is significant and shall be preserved when processing the array.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 549, 1)))

def _BuildAutomaton_521 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_521
    del _BuildAutomaton_521
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 39, 3))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 40, 3))
    counters.add(cc_1)
    cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 41, 3))
    counters.add(cc_2)
    cc_3 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 42, 3))
    counters.add(cc_3)
    cc_4 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 43, 3))
    counters.add(cc_4)
    states = []
    final_update = None
    symbol = pyxb.binding.content.ElementUse(SurfaceType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'metaDataProperty')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 39, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(SurfaceType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'description')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 40, 3))
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(SurfaceType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'descriptionReference')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 41, 3))
    st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(SurfaceType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'identifier')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 42, 3))
    st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_3)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(SurfaceType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'name')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 43, 3))
    st_4 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_4)
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(SurfaceType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'patches')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 502, 5))
    st_5 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_5)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_1, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_1, False) ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_2, True) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_2, False) ]))
    st_2._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_3, True) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_3, False) ]))
    st_3._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_4, True) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_4, False) ]))
    st_4._set_transitionSet(transitions)
    transitions = []
    st_5._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
SurfaceType._Automaton = _BuildAutomaton_521()




OrientableSurfaceType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'baseSurface'), SurfacePropertyType, scope=OrientableSurfaceType, documentation='The property baseSurface references or contains the base surface. The property baseSurface either references the base surface via the XLink-attributes or contains the surface element. A surface element is any element which is substitutable for gml:AbstractSurface. The base surface has positive orientation.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 523, 1)))

def _BuildAutomaton_522 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_522
    del _BuildAutomaton_522
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 39, 3))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 40, 3))
    counters.add(cc_1)
    cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 41, 3))
    counters.add(cc_2)
    cc_3 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 42, 3))
    counters.add(cc_3)
    cc_4 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 43, 3))
    counters.add(cc_4)
    states = []
    final_update = None
    symbol = pyxb.binding.content.ElementUse(OrientableSurfaceType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'metaDataProperty')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 39, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(OrientableSurfaceType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'description')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 40, 3))
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(OrientableSurfaceType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'descriptionReference')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 41, 3))
    st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(OrientableSurfaceType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'identifier')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 42, 3))
    st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_3)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(OrientableSurfaceType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'name')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 43, 3))
    st_4 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_4)
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(OrientableSurfaceType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'baseSurface')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 517, 5))
    st_5 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_5)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_1, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_1, False) ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_2, True) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_2, False) ]))
    st_2._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_3, True) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_3, False) ]))
    st_3._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_4, True) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_4, False) ]))
    st_4._set_transitionSet(transitions)
    transitions = []
    st_5._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
OrientableSurfaceType._Automaton = _BuildAutomaton_522()




SolidType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'exterior'), ShellPropertyType, scope=SolidType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 808, 5)))

SolidType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'interior'), ShellPropertyType, scope=SolidType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 809, 5)))

def _BuildAutomaton_523 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_523
    del _BuildAutomaton_523
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 39, 3))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 40, 3))
    counters.add(cc_1)
    cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 41, 3))
    counters.add(cc_2)
    cc_3 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 42, 3))
    counters.add(cc_3)
    cc_4 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 43, 3))
    counters.add(cc_4)
    cc_5 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 808, 5))
    counters.add(cc_5)
    cc_6 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 809, 5))
    counters.add(cc_6)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(SolidType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'metaDataProperty')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 39, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_1, False))
    symbol = pyxb.binding.content.ElementUse(SolidType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'description')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 40, 3))
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_2, False))
    symbol = pyxb.binding.content.ElementUse(SolidType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'descriptionReference')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 41, 3))
    st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_3, False))
    symbol = pyxb.binding.content.ElementUse(SolidType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'identifier')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 42, 3))
    st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_3)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_4, False))
    symbol = pyxb.binding.content.ElementUse(SolidType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'name')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 43, 3))
    st_4 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_4)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_5, False))
    symbol = pyxb.binding.content.ElementUse(SolidType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'exterior')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 808, 5))
    st_5 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_5)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_6, False))
    symbol = pyxb.binding.content.ElementUse(SolidType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'interior')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 809, 5))
    st_6 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_6)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_1, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_1, False) ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_2, True) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_2, False) ]))
    st_2._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_3, True) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_3, False) ]))
    st_3._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_4, True) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_4, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_4, False) ]))
    st_4._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_5, True) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_5, False) ]))
    st_5._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_6, True) ]))
    st_6._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
SolidType._Automaton = _BuildAutomaton_523()




ShellType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'surfaceMember'), SurfacePropertyType, scope=ShellType, documentation='This property element either references a surface via the XLink-attributes or contains the surface element. A surface element is any element, which is substitutable for gml:AbstractSurface.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 837, 1)))

def _BuildAutomaton_524 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_524
    del _BuildAutomaton_524
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 39, 3))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 40, 3))
    counters.add(cc_1)
    cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 41, 3))
    counters.add(cc_2)
    cc_3 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 42, 3))
    counters.add(cc_3)
    cc_4 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 43, 3))
    counters.add(cc_4)
    states = []
    final_update = None
    symbol = pyxb.binding.content.ElementUse(ShellType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'metaDataProperty')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 39, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(ShellType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'description')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 40, 3))
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(ShellType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'descriptionReference')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 41, 3))
    st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(ShellType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'identifier')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 42, 3))
    st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_3)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(ShellType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'name')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 43, 3))
    st_4 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_4)
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(ShellType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'surfaceMember')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 823, 5))
    st_5 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_5)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_1, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_1, False) ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_2, True) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_2, False) ]))
    st_2._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_3, True) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_3, False) ]))
    st_3._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_4, True) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_4, False) ]))
    st_4._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_5, [
         ]))
    st_5._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
ShellType._Automaton = _BuildAutomaton_524()




DirectedObservationAtDistanceType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'distance'), MeasureType, scope=DirectedObservationAtDistanceType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/observation.xsd', 90, 5)))

def _BuildAutomaton_525 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_525
    del _BuildAutomaton_525
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 39, 3))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 40, 3))
    counters.add(cc_1)
    cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 41, 3))
    counters.add(cc_2)
    cc_3 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 42, 3))
    counters.add(cc_3)
    cc_4 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 43, 3))
    counters.add(cc_4)
    cc_5 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/feature.xsd', 26, 5))
    counters.add(cc_5)
    cc_6 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/feature.xsd', 27, 5))
    counters.add(cc_6)
    cc_7 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/observation.xsd', 34, 5))
    counters.add(cc_7)
    cc_8 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/observation.xsd', 35, 5))
    counters.add(cc_8)
    states = []
    final_update = None
    symbol = pyxb.binding.content.ElementUse(DirectedObservationAtDistanceType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'metaDataProperty')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 39, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(DirectedObservationAtDistanceType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'description')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 40, 3))
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(DirectedObservationAtDistanceType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'descriptionReference')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 41, 3))
    st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(DirectedObservationAtDistanceType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'identifier')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 42, 3))
    st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_3)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(DirectedObservationAtDistanceType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'name')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 43, 3))
    st_4 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_4)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(DirectedObservationAtDistanceType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'boundedBy')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/feature.xsd', 26, 5))
    st_5 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_5)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(DirectedObservationAtDistanceType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'location')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/feature.xsd', 27, 5))
    st_6 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_6)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(DirectedObservationAtDistanceType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'validTime')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/observation.xsd', 33, 5))
    st_7 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_7)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(DirectedObservationAtDistanceType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'using')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/observation.xsd', 34, 5))
    st_8 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_8)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(DirectedObservationAtDistanceType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'target')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/observation.xsd', 35, 5))
    st_9 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_9)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(DirectedObservationAtDistanceType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'resultOf')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/observation.xsd', 36, 5))
    st_10 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_10)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(DirectedObservationAtDistanceType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'direction')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/observation.xsd', 76, 5))
    st_11 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_11)
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(DirectedObservationAtDistanceType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'distance')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/observation.xsd', 90, 5))
    st_12 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_12)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_1, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_1, False) ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_2, True) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_2, False) ]))
    st_2._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_3, True) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_3, False) ]))
    st_3._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_4, True) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_4, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_4, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_4, False) ]))
    st_4._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_5, True) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_5, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_5, False) ]))
    st_5._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_6, True) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_6, False) ]))
    st_6._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_8, [
         ]))
    transitions.append(fac.Transition(st_9, [
         ]))
    transitions.append(fac.Transition(st_10, [
         ]))
    st_7._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_8, [
        fac.UpdateInstruction(cc_7, True) ]))
    transitions.append(fac.Transition(st_9, [
        fac.UpdateInstruction(cc_7, False) ]))
    transitions.append(fac.Transition(st_10, [
        fac.UpdateInstruction(cc_7, False) ]))
    st_8._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_9, [
        fac.UpdateInstruction(cc_8, True) ]))
    transitions.append(fac.Transition(st_10, [
        fac.UpdateInstruction(cc_8, False) ]))
    st_9._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_11, [
         ]))
    st_10._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_12, [
         ]))
    st_11._set_transitionSet(transitions)
    transitions = []
    st_12._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
DirectedObservationAtDistanceType._Automaton = _BuildAutomaton_525()




AbstractCRSType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'domainOfValidity'), CTD_ANON_8, scope=AbstractCRSType, documentation='The gml:domainOfValidity property implements an association role to an EX_Extent object as encoded in ISO/TS 19139, either referencing or containing the definition of that extent.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/referenceSystems.xsd', 45, 1)))

AbstractCRSType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'scope'), pyxb.binding.datatypes.string, scope=AbstractCRSType, documentation='The gml:scope property provides a description of the usage, or limitations of usage, for which this CRS-related object is valid. If unknown, enter "not known".', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/referenceSystems.xsd', 56, 1)))

def _BuildAutomaton_526 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_526
    del _BuildAutomaton_526
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 35, 5))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 36, 5))
    counters.add(cc_1)
    cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 37, 5))
    counters.add(cc_2)
    cc_3 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 39, 5))
    counters.add(cc_3)
    cc_4 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 49, 5))
    counters.add(cc_4)
    cc_5 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/referenceSystems.xsd', 39, 5))
    counters.add(cc_5)
    states = []
    final_update = None
    symbol = pyxb.binding.content.ElementUse(AbstractCRSType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'metaDataProperty')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 35, 5))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(AbstractCRSType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'description')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 36, 5))
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(AbstractCRSType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'descriptionReference')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 37, 5))
    st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(AbstractCRSType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'identifier')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 38, 5))
    st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_3)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(AbstractCRSType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'name')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 39, 5))
    st_4 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_4)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(AbstractCRSType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'remarks')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 49, 5))
    st_5 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_5)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(AbstractCRSType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'domainOfValidity')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/referenceSystems.xsd', 39, 5))
    st_6 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_6)
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(AbstractCRSType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'scope')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/referenceSystems.xsd', 40, 5))
    st_7 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_7)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_1, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_1, False) ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_2, True) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_2, False) ]))
    st_2._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
         ]))
    transitions.append(fac.Transition(st_5, [
         ]))
    transitions.append(fac.Transition(st_6, [
         ]))
    transitions.append(fac.Transition(st_7, [
         ]))
    st_3._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_3, True) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_3, False) ]))
    st_4._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_4, True) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_4, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_4, False) ]))
    st_5._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_5, True) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_5, False) ]))
    st_6._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_7, [
         ]))
    st_7._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
AbstractCRSType._Automaton = _BuildAutomaton_526()




TimeInstantType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'timePosition'), TimePositionType, scope=TimeInstantType, documentation='This element is used directly as a property of gml:TimeInstant (see 15.2.2.3), and may also be used in application schemas.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporal.xsd', 215, 1)))

def _BuildAutomaton_527 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_527
    del _BuildAutomaton_527
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 39, 3))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 40, 3))
    counters.add(cc_1)
    cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 41, 3))
    counters.add(cc_2)
    cc_3 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 42, 3))
    counters.add(cc_3)
    cc_4 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 43, 3))
    counters.add(cc_4)
    cc_5 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporal.xsd', 37, 5))
    counters.add(cc_5)
    states = []
    final_update = None
    symbol = pyxb.binding.content.ElementUse(TimeInstantType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'metaDataProperty')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 39, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(TimeInstantType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'description')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 40, 3))
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(TimeInstantType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'descriptionReference')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 41, 3))
    st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(TimeInstantType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'identifier')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 42, 3))
    st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_3)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(TimeInstantType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'name')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 43, 3))
    st_4 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_4)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(TimeInstantType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'relatedTime')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporal.xsd', 37, 5))
    st_5 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_5)
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(TimeInstantType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'timePosition')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporal.xsd', 118, 5))
    st_6 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_6)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_1, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_1, False) ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_2, True) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_2, False) ]))
    st_2._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_3, True) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_3, False) ]))
    st_3._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_4, True) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_4, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_4, False) ]))
    st_4._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_5, True) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_5, False) ]))
    st_5._set_transitionSet(transitions)
    transitions = []
    st_6._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
TimeInstantType._Automaton = _BuildAutomaton_527()




TimePeriodType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'beginPosition'), TimePositionType, scope=TimePeriodType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporal.xsd', 146, 6)))

TimePeriodType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'begin'), TimeInstantPropertyType, scope=TimePeriodType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporal.xsd', 147, 6)))

TimePeriodType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'endPosition'), TimePositionType, scope=TimePeriodType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporal.xsd', 150, 6)))

TimePeriodType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'end'), TimeInstantPropertyType, scope=TimePeriodType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporal.xsd', 151, 6)))

TimePeriodType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'duration'), pyxb.binding.datatypes.duration, scope=TimePeriodType, documentation='gml:duration conforms to the ISO 8601 syntax for temporal length as implemented by the XML Schema duration type.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporal.xsd', 229, 1)))

TimePeriodType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'timeInterval'), TimeIntervalLengthType, scope=TimePeriodType, documentation=' gml:timeInterval conforms to ISO 11404 which is based on floating point values for temporal length.\nISO 11404 syntax specifies the use of a positiveInteger together with appropriate values for radix and factor. The resolution of the time interval is to one radix ^(-factor) of the specified time unit.\nThe value of the unit is either selected from the units for time intervals from ISO 31-1:1992, or is another suitable unit.  The encoding is defined for GML in gml:TimeUnitType. The second component of this union type provides a method for indicating time units other than the six standard units given in the enumeration.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporal.xsd', 234, 1)))

def _BuildAutomaton_528 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_528
    del _BuildAutomaton_528
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 39, 3))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 40, 3))
    counters.add(cc_1)
    cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 41, 3))
    counters.add(cc_2)
    cc_3 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 42, 3))
    counters.add(cc_3)
    cc_4 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 43, 3))
    counters.add(cc_4)
    cc_5 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporal.xsd', 37, 5))
    counters.add(cc_5)
    cc_6 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporal.xsd', 153, 5))
    counters.add(cc_6)
    states = []
    final_update = None
    symbol = pyxb.binding.content.ElementUse(TimePeriodType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'metaDataProperty')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 39, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(TimePeriodType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'description')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 40, 3))
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(TimePeriodType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'descriptionReference')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 41, 3))
    st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(TimePeriodType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'identifier')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 42, 3))
    st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_3)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(TimePeriodType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'name')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 43, 3))
    st_4 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_4)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(TimePeriodType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'relatedTime')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporal.xsd', 37, 5))
    st_5 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_5)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(TimePeriodType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'beginPosition')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporal.xsd', 146, 6))
    st_6 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_6)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(TimePeriodType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'begin')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporal.xsd', 147, 6))
    st_7 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_7)
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(TimePeriodType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'endPosition')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporal.xsd', 150, 6))
    st_8 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_8)
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(TimePeriodType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'end')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporal.xsd', 151, 6))
    st_9 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_9)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_6, False))
    symbol = pyxb.binding.content.ElementUse(TimePeriodType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'duration')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporal.xsd', 225, 3))
    st_10 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_10)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_6, False))
    symbol = pyxb.binding.content.ElementUse(TimePeriodType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'timeInterval')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporal.xsd', 226, 3))
    st_11 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_11)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_1, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_1, False) ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_2, True) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_2, False) ]))
    st_2._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_3, True) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_3, False) ]))
    st_3._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_4, True) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_4, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_4, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_4, False) ]))
    st_4._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_5, True) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_5, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_5, False) ]))
    st_5._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_8, [
         ]))
    transitions.append(fac.Transition(st_9, [
         ]))
    st_6._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_8, [
         ]))
    transitions.append(fac.Transition(st_9, [
         ]))
    st_7._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_10, [
         ]))
    transitions.append(fac.Transition(st_11, [
         ]))
    st_8._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_10, [
         ]))
    transitions.append(fac.Transition(st_11, [
         ]))
    st_9._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_10, [
        fac.UpdateInstruction(cc_6, True) ]))
    transitions.append(fac.Transition(st_11, [
        fac.UpdateInstruction(cc_6, True) ]))
    st_10._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_10, [
        fac.UpdateInstruction(cc_6, True) ]))
    transitions.append(fac.Transition(st_11, [
        fac.UpdateInstruction(cc_6, True) ]))
    st_11._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
TimePeriodType._Automaton = _BuildAutomaton_528()




TimeCoordinateSystemType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'originPosition'), TimePositionType, scope=TimeCoordinateSystemType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporalReferenceSystems.xsd', 45, 6)))

TimeCoordinateSystemType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'origin'), TimeInstantPropertyType, scope=TimeCoordinateSystemType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporalReferenceSystems.xsd', 46, 6)))

TimeCoordinateSystemType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'interval'), TimeIntervalLengthType, scope=TimeCoordinateSystemType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporalReferenceSystems.xsd', 48, 5)))

def _BuildAutomaton_529 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_529
    del _BuildAutomaton_529
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 35, 5))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 36, 5))
    counters.add(cc_1)
    cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 37, 5))
    counters.add(cc_2)
    cc_3 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 39, 5))
    counters.add(cc_3)
    cc_4 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 49, 5))
    counters.add(cc_4)
    states = []
    final_update = None
    symbol = pyxb.binding.content.ElementUse(TimeCoordinateSystemType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'metaDataProperty')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 35, 5))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(TimeCoordinateSystemType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'description')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 36, 5))
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(TimeCoordinateSystemType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'descriptionReference')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 37, 5))
    st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(TimeCoordinateSystemType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'identifier')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 38, 5))
    st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_3)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(TimeCoordinateSystemType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'name')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 39, 5))
    st_4 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_4)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(TimeCoordinateSystemType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'remarks')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 49, 5))
    st_5 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_5)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(TimeCoordinateSystemType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'domainOfValidity')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporalReferenceSystems.xsd', 26, 5))
    st_6 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_6)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(TimeCoordinateSystemType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'originPosition')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporalReferenceSystems.xsd', 45, 6))
    st_7 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_7)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(TimeCoordinateSystemType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'origin')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporalReferenceSystems.xsd', 46, 6))
    st_8 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_8)
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(TimeCoordinateSystemType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'interval')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporalReferenceSystems.xsd', 48, 5))
    st_9 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_9)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_1, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_1, False) ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_2, True) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_2, False) ]))
    st_2._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
         ]))
    transitions.append(fac.Transition(st_5, [
         ]))
    transitions.append(fac.Transition(st_6, [
         ]))
    st_3._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_3, True) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_3, False) ]))
    st_4._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_4, True) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_4, False) ]))
    st_5._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_7, [
         ]))
    transitions.append(fac.Transition(st_8, [
         ]))
    st_6._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_9, [
         ]))
    st_7._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_9, [
         ]))
    st_8._set_transitionSet(transitions)
    transitions = []
    st_9._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
TimeCoordinateSystemType._Automaton = _BuildAutomaton_529()




TimeCalendarType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'referenceFrame'), TimeCalendarEraPropertyType, scope=TimeCalendarType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporalReferenceSystems.xsd', 64, 5)))

def _BuildAutomaton_530 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_530
    del _BuildAutomaton_530
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 35, 5))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 36, 5))
    counters.add(cc_1)
    cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 37, 5))
    counters.add(cc_2)
    cc_3 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 39, 5))
    counters.add(cc_3)
    cc_4 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 49, 5))
    counters.add(cc_4)
    states = []
    final_update = None
    symbol = pyxb.binding.content.ElementUse(TimeCalendarType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'metaDataProperty')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 35, 5))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(TimeCalendarType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'description')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 36, 5))
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(TimeCalendarType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'descriptionReference')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 37, 5))
    st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(TimeCalendarType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'identifier')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 38, 5))
    st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_3)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(TimeCalendarType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'name')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 39, 5))
    st_4 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_4)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(TimeCalendarType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'remarks')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 49, 5))
    st_5 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_5)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(TimeCalendarType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'domainOfValidity')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporalReferenceSystems.xsd', 26, 5))
    st_6 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_6)
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(TimeCalendarType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'referenceFrame')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporalReferenceSystems.xsd', 64, 5))
    st_7 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_7)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_1, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_1, False) ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_2, True) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_2, False) ]))
    st_2._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
         ]))
    transitions.append(fac.Transition(st_5, [
         ]))
    transitions.append(fac.Transition(st_6, [
         ]))
    st_3._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_3, True) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_3, False) ]))
    st_4._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_4, True) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_4, False) ]))
    st_5._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_7, [
         ]))
    st_6._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_7, [
         ]))
    st_7._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
TimeCalendarType._Automaton = _BuildAutomaton_530()




TimeClockType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'referenceEvent'), StringOrRefType, scope=TimeClockType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporalReferenceSystems.xsd', 124, 5)))

TimeClockType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'referenceTime'), pyxb.binding.datatypes.time, scope=TimeClockType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporalReferenceSystems.xsd', 125, 5)))

TimeClockType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'utcReference'), pyxb.binding.datatypes.time, scope=TimeClockType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporalReferenceSystems.xsd', 126, 5)))

TimeClockType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'dateBasis'), TimeCalendarPropertyType, scope=TimeClockType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporalReferenceSystems.xsd', 127, 5)))

def _BuildAutomaton_531 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_531
    del _BuildAutomaton_531
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 35, 5))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 36, 5))
    counters.add(cc_1)
    cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 37, 5))
    counters.add(cc_2)
    cc_3 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 39, 5))
    counters.add(cc_3)
    cc_4 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 49, 5))
    counters.add(cc_4)
    cc_5 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporalReferenceSystems.xsd', 127, 5))
    counters.add(cc_5)
    states = []
    final_update = None
    symbol = pyxb.binding.content.ElementUse(TimeClockType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'metaDataProperty')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 35, 5))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(TimeClockType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'description')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 36, 5))
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(TimeClockType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'descriptionReference')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 37, 5))
    st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(TimeClockType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'identifier')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 38, 5))
    st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_3)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(TimeClockType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'name')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 39, 5))
    st_4 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_4)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(TimeClockType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'remarks')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 49, 5))
    st_5 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_5)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(TimeClockType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'domainOfValidity')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporalReferenceSystems.xsd', 26, 5))
    st_6 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_6)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(TimeClockType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'referenceEvent')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporalReferenceSystems.xsd', 124, 5))
    st_7 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_7)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(TimeClockType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'referenceTime')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporalReferenceSystems.xsd', 125, 5))
    st_8 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_8)
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(TimeClockType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'utcReference')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporalReferenceSystems.xsd', 126, 5))
    st_9 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_9)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_5, False))
    symbol = pyxb.binding.content.ElementUse(TimeClockType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'dateBasis')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporalReferenceSystems.xsd', 127, 5))
    st_10 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_10)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_1, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_1, False) ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_2, True) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_2, False) ]))
    st_2._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
         ]))
    transitions.append(fac.Transition(st_5, [
         ]))
    transitions.append(fac.Transition(st_6, [
         ]))
    st_3._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_3, True) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_3, False) ]))
    st_4._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_4, True) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_4, False) ]))
    st_5._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_7, [
         ]))
    st_6._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_8, [
         ]))
    st_7._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_9, [
         ]))
    st_8._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_10, [
         ]))
    st_9._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_10, [
        fac.UpdateInstruction(cc_5, True) ]))
    st_10._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
TimeClockType._Automaton = _BuildAutomaton_531()




TimeOrdinalReferenceSystemType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'component'), TimeOrdinalEraPropertyType, scope=TimeOrdinalReferenceSystemType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporalReferenceSystems.xsd', 154, 5)))

def _BuildAutomaton_532 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_532
    del _BuildAutomaton_532
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 35, 5))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 36, 5))
    counters.add(cc_1)
    cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 37, 5))
    counters.add(cc_2)
    cc_3 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 39, 5))
    counters.add(cc_3)
    cc_4 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 49, 5))
    counters.add(cc_4)
    states = []
    final_update = None
    symbol = pyxb.binding.content.ElementUse(TimeOrdinalReferenceSystemType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'metaDataProperty')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 35, 5))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(TimeOrdinalReferenceSystemType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'description')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 36, 5))
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(TimeOrdinalReferenceSystemType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'descriptionReference')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 37, 5))
    st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(TimeOrdinalReferenceSystemType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'identifier')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 38, 5))
    st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_3)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(TimeOrdinalReferenceSystemType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'name')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 39, 5))
    st_4 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_4)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(TimeOrdinalReferenceSystemType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'remarks')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 49, 5))
    st_5 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_5)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(TimeOrdinalReferenceSystemType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'domainOfValidity')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporalReferenceSystems.xsd', 26, 5))
    st_6 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_6)
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(TimeOrdinalReferenceSystemType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'component')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporalReferenceSystems.xsd', 154, 5))
    st_7 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_7)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_1, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_1, False) ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_2, True) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_2, False) ]))
    st_2._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
         ]))
    transitions.append(fac.Transition(st_5, [
         ]))
    transitions.append(fac.Transition(st_6, [
         ]))
    st_3._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_3, True) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_3, False) ]))
    st_4._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_4, True) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_4, False) ]))
    st_5._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_7, [
         ]))
    st_6._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_7, [
         ]))
    st_7._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
TimeOrdinalReferenceSystemType._Automaton = _BuildAutomaton_532()




TimeNodeType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'previousEdge'), TimeEdgePropertyType, scope=TimeNodeType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporalTopology.xsd', 76, 5)))

TimeNodeType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'nextEdge'), TimeEdgePropertyType, scope=TimeNodeType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporalTopology.xsd', 77, 5)))

TimeNodeType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'position'), TimeInstantPropertyType, scope=TimeNodeType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporalTopology.xsd', 78, 5)))

def _BuildAutomaton_533 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_533
    del _BuildAutomaton_533
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 39, 3))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 40, 3))
    counters.add(cc_1)
    cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 41, 3))
    counters.add(cc_2)
    cc_3 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 42, 3))
    counters.add(cc_3)
    cc_4 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 43, 3))
    counters.add(cc_4)
    cc_5 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporal.xsd', 37, 5))
    counters.add(cc_5)
    cc_6 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporalTopology.xsd', 26, 5))
    counters.add(cc_6)
    cc_7 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporalTopology.xsd', 76, 5))
    counters.add(cc_7)
    cc_8 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporalTopology.xsd', 77, 5))
    counters.add(cc_8)
    cc_9 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporalTopology.xsd', 78, 5))
    counters.add(cc_9)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(TimeNodeType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'metaDataProperty')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 39, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_1, False))
    symbol = pyxb.binding.content.ElementUse(TimeNodeType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'description')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 40, 3))
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_2, False))
    symbol = pyxb.binding.content.ElementUse(TimeNodeType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'descriptionReference')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 41, 3))
    st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_3, False))
    symbol = pyxb.binding.content.ElementUse(TimeNodeType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'identifier')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 42, 3))
    st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_3)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_4, False))
    symbol = pyxb.binding.content.ElementUse(TimeNodeType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'name')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 43, 3))
    st_4 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_4)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_5, False))
    symbol = pyxb.binding.content.ElementUse(TimeNodeType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'relatedTime')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporal.xsd', 37, 5))
    st_5 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_5)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_6, False))
    symbol = pyxb.binding.content.ElementUse(TimeNodeType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'complex')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporalTopology.xsd', 26, 5))
    st_6 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_6)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_7, False))
    symbol = pyxb.binding.content.ElementUse(TimeNodeType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'previousEdge')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporalTopology.xsd', 76, 5))
    st_7 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_7)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_8, False))
    symbol = pyxb.binding.content.ElementUse(TimeNodeType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'nextEdge')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporalTopology.xsd', 77, 5))
    st_8 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_8)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_9, False))
    symbol = pyxb.binding.content.ElementUse(TimeNodeType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'position')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporalTopology.xsd', 78, 5))
    st_9 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_9)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_8, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_9, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_1, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_8, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_9, [
        fac.UpdateInstruction(cc_1, False) ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_2, True) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_8, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_9, [
        fac.UpdateInstruction(cc_2, False) ]))
    st_2._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_3, True) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_8, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_9, [
        fac.UpdateInstruction(cc_3, False) ]))
    st_3._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_4, True) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_4, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_4, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_4, False) ]))
    transitions.append(fac.Transition(st_8, [
        fac.UpdateInstruction(cc_4, False) ]))
    transitions.append(fac.Transition(st_9, [
        fac.UpdateInstruction(cc_4, False) ]))
    st_4._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_5, True) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_5, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_5, False) ]))
    transitions.append(fac.Transition(st_8, [
        fac.UpdateInstruction(cc_5, False) ]))
    transitions.append(fac.Transition(st_9, [
        fac.UpdateInstruction(cc_5, False) ]))
    st_5._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_6, True) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_6, False) ]))
    transitions.append(fac.Transition(st_8, [
        fac.UpdateInstruction(cc_6, False) ]))
    transitions.append(fac.Transition(st_9, [
        fac.UpdateInstruction(cc_6, False) ]))
    st_6._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_7, True) ]))
    transitions.append(fac.Transition(st_8, [
        fac.UpdateInstruction(cc_7, False) ]))
    transitions.append(fac.Transition(st_9, [
        fac.UpdateInstruction(cc_7, False) ]))
    st_7._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_8, [
        fac.UpdateInstruction(cc_8, True) ]))
    transitions.append(fac.Transition(st_9, [
        fac.UpdateInstruction(cc_8, False) ]))
    st_8._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_9, [
        fac.UpdateInstruction(cc_9, True) ]))
    st_9._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
TimeNodeType._Automaton = _BuildAutomaton_533()




TimeEdgeType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'start'), TimeNodePropertyType, scope=TimeEdgeType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporalTopology.xsd', 102, 5)))

TimeEdgeType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'end'), TimeNodePropertyType, scope=TimeEdgeType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporalTopology.xsd', 103, 5)))

TimeEdgeType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'extent'), TimePeriodPropertyType, scope=TimeEdgeType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporalTopology.xsd', 104, 5)))

def _BuildAutomaton_534 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_534
    del _BuildAutomaton_534
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 39, 3))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 40, 3))
    counters.add(cc_1)
    cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 41, 3))
    counters.add(cc_2)
    cc_3 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 42, 3))
    counters.add(cc_3)
    cc_4 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 43, 3))
    counters.add(cc_4)
    cc_5 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporal.xsd', 37, 5))
    counters.add(cc_5)
    cc_6 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporalTopology.xsd', 26, 5))
    counters.add(cc_6)
    cc_7 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporalTopology.xsd', 104, 5))
    counters.add(cc_7)
    states = []
    final_update = None
    symbol = pyxb.binding.content.ElementUse(TimeEdgeType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'metaDataProperty')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 39, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(TimeEdgeType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'description')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 40, 3))
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(TimeEdgeType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'descriptionReference')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 41, 3))
    st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(TimeEdgeType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'identifier')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 42, 3))
    st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_3)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(TimeEdgeType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'name')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 43, 3))
    st_4 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_4)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(TimeEdgeType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'relatedTime')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporal.xsd', 37, 5))
    st_5 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_5)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(TimeEdgeType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'complex')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporalTopology.xsd', 26, 5))
    st_6 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_6)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(TimeEdgeType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'start')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporalTopology.xsd', 102, 5))
    st_7 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_7)
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(TimeEdgeType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'end')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporalTopology.xsd', 103, 5))
    st_8 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_8)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_7, False))
    symbol = pyxb.binding.content.ElementUse(TimeEdgeType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'extent')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/temporalTopology.xsd', 104, 5))
    st_9 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_9)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_1, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_1, False) ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_2, True) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_2, False) ]))
    st_2._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_3, True) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_3, False) ]))
    st_3._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_4, True) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_4, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_4, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_4, False) ]))
    st_4._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_5, True) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_5, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_5, False) ]))
    st_5._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_6, True) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_6, False) ]))
    st_6._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_8, [
         ]))
    st_7._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_9, [
         ]))
    st_8._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_9, [
        fac.UpdateInstruction(cc_7, True) ]))
    st_9._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
TimeEdgeType._Automaton = _BuildAutomaton_534()




BaseUnitType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'unitsSystem'), ReferenceType, scope=BaseUnitType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/units.xsd', 75, 5)))

def _BuildAutomaton_535 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_535
    del _BuildAutomaton_535
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 35, 5))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 36, 5))
    counters.add(cc_1)
    cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 37, 5))
    counters.add(cc_2)
    cc_3 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 39, 5))
    counters.add(cc_3)
    cc_4 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 49, 5))
    counters.add(cc_4)
    cc_5 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/units.xsd', 41, 5))
    counters.add(cc_5)
    cc_6 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/units.xsd', 42, 5))
    counters.add(cc_6)
    cc_7 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/units.xsd', 43, 5))
    counters.add(cc_7)
    states = []
    final_update = None
    symbol = pyxb.binding.content.ElementUse(BaseUnitType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'metaDataProperty')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 35, 5))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(BaseUnitType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'description')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 36, 5))
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(BaseUnitType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'descriptionReference')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 37, 5))
    st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(BaseUnitType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'identifier')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 38, 5))
    st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_3)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(BaseUnitType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'name')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 39, 5))
    st_4 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_4)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(BaseUnitType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'remarks')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 49, 5))
    st_5 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_5)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(BaseUnitType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'quantityType')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/units.xsd', 41, 5))
    st_6 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_6)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(BaseUnitType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'quantityTypeReference')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/units.xsd', 42, 5))
    st_7 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_7)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(BaseUnitType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'catalogSymbol')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/units.xsd', 43, 5))
    st_8 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_8)
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(BaseUnitType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'unitsSystem')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/units.xsd', 75, 5))
    st_9 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_9)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_1, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_1, False) ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_2, True) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_2, False) ]))
    st_2._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
         ]))
    transitions.append(fac.Transition(st_5, [
         ]))
    transitions.append(fac.Transition(st_6, [
         ]))
    transitions.append(fac.Transition(st_7, [
         ]))
    transitions.append(fac.Transition(st_8, [
         ]))
    transitions.append(fac.Transition(st_9, [
         ]))
    st_3._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_3, True) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_8, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_9, [
        fac.UpdateInstruction(cc_3, False) ]))
    st_4._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_4, True) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_4, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_4, False) ]))
    transitions.append(fac.Transition(st_8, [
        fac.UpdateInstruction(cc_4, False) ]))
    transitions.append(fac.Transition(st_9, [
        fac.UpdateInstruction(cc_4, False) ]))
    st_5._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_5, True) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_5, False) ]))
    transitions.append(fac.Transition(st_8, [
        fac.UpdateInstruction(cc_5, False) ]))
    transitions.append(fac.Transition(st_9, [
        fac.UpdateInstruction(cc_5, False) ]))
    st_6._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_6, True) ]))
    transitions.append(fac.Transition(st_8, [
        fac.UpdateInstruction(cc_6, False) ]))
    transitions.append(fac.Transition(st_9, [
        fac.UpdateInstruction(cc_6, False) ]))
    st_7._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_8, [
        fac.UpdateInstruction(cc_7, True) ]))
    transitions.append(fac.Transition(st_9, [
        fac.UpdateInstruction(cc_7, False) ]))
    st_8._set_transitionSet(transitions)
    transitions = []
    st_9._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
BaseUnitType._Automaton = _BuildAutomaton_535()




DerivedUnitType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'derivationUnitTerm'), DerivationUnitTermType, scope=DerivedUnitType, documentation='A set of gml:derivationUnitTerm elements describes a derived unit of measure.  Each element carries an integer exponent.  The terms are combined by raising each referenced unit to the power of its exponent and forming the product.\nThis unit term references another unit of measure (uom) and provides an integer exponent applied to that unit in defining the compound unit. The exponent may be positive or negative, but not zero.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/units.xsd', 95, 1)))

def _BuildAutomaton_536 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_536
    del _BuildAutomaton_536
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 35, 5))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 36, 5))
    counters.add(cc_1)
    cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 37, 5))
    counters.add(cc_2)
    cc_3 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 39, 5))
    counters.add(cc_3)
    cc_4 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 49, 5))
    counters.add(cc_4)
    cc_5 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/units.xsd', 41, 5))
    counters.add(cc_5)
    cc_6 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/units.xsd', 42, 5))
    counters.add(cc_6)
    cc_7 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/units.xsd', 43, 5))
    counters.add(cc_7)
    states = []
    final_update = None
    symbol = pyxb.binding.content.ElementUse(DerivedUnitType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'metaDataProperty')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 35, 5))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(DerivedUnitType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'description')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 36, 5))
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(DerivedUnitType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'descriptionReference')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 37, 5))
    st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(DerivedUnitType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'identifier')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 38, 5))
    st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_3)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(DerivedUnitType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'name')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 39, 5))
    st_4 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_4)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(DerivedUnitType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'remarks')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 49, 5))
    st_5 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_5)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(DerivedUnitType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'quantityType')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/units.xsd', 41, 5))
    st_6 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_6)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(DerivedUnitType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'quantityTypeReference')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/units.xsd', 42, 5))
    st_7 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_7)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(DerivedUnitType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'catalogSymbol')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/units.xsd', 43, 5))
    st_8 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_8)
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(DerivedUnitType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'derivationUnitTerm')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/units.xsd', 90, 5))
    st_9 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_9)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_1, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_1, False) ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_2, True) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_2, False) ]))
    st_2._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
         ]))
    transitions.append(fac.Transition(st_5, [
         ]))
    transitions.append(fac.Transition(st_6, [
         ]))
    transitions.append(fac.Transition(st_7, [
         ]))
    transitions.append(fac.Transition(st_8, [
         ]))
    transitions.append(fac.Transition(st_9, [
         ]))
    st_3._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_3, True) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_8, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_9, [
        fac.UpdateInstruction(cc_3, False) ]))
    st_4._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_4, True) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_4, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_4, False) ]))
    transitions.append(fac.Transition(st_8, [
        fac.UpdateInstruction(cc_4, False) ]))
    transitions.append(fac.Transition(st_9, [
        fac.UpdateInstruction(cc_4, False) ]))
    st_5._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_5, True) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_5, False) ]))
    transitions.append(fac.Transition(st_8, [
        fac.UpdateInstruction(cc_5, False) ]))
    transitions.append(fac.Transition(st_9, [
        fac.UpdateInstruction(cc_5, False) ]))
    st_6._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_6, True) ]))
    transitions.append(fac.Transition(st_8, [
        fac.UpdateInstruction(cc_6, False) ]))
    transitions.append(fac.Transition(st_9, [
        fac.UpdateInstruction(cc_6, False) ]))
    st_7._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_8, [
        fac.UpdateInstruction(cc_7, True) ]))
    transitions.append(fac.Transition(st_9, [
        fac.UpdateInstruction(cc_7, False) ]))
    st_8._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_9, [
         ]))
    st_9._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
DerivedUnitType._Automaton = _BuildAutomaton_536()




ConventionalUnitType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'derivationUnitTerm'), DerivationUnitTermType, scope=ConventionalUnitType, documentation='A set of gml:derivationUnitTerm elements describes a derived unit of measure.  Each element carries an integer exponent.  The terms are combined by raising each referenced unit to the power of its exponent and forming the product.\nThis unit term references another unit of measure (uom) and provides an integer exponent applied to that unit in defining the compound unit. The exponent may be positive or negative, but not zero.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/units.xsd', 95, 1)))

ConventionalUnitType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'conversionToPreferredUnit'), ConversionToPreferredUnitType, scope=ConventionalUnitType, documentation='The elements gml:conversionToPreferredUnit and gml:roughConversionToPreferredUnit represent parameters used to convert conventional units to preferred units for this physical quantity type.  A preferred unit is either a Base Unit or a Derived Unit that is selected for all values of one physical quantity type.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/units.xsd', 127, 1)))

ConventionalUnitType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'roughConversionToPreferredUnit'), ConversionToPreferredUnitType, scope=ConventionalUnitType, documentation='The elements gml:conversionToPreferredUnit and gml:roughConversionToPreferredUnit represent parameters used to convert conventional units to preferred units for this physical quantity type.  A preferred unit is either a Base Unit or a Derived Unit that is selected for all values of one physical quantity type.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/units.xsd', 132, 1)))

def _BuildAutomaton_537 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_537
    del _BuildAutomaton_537
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 35, 5))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 36, 5))
    counters.add(cc_1)
    cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 37, 5))
    counters.add(cc_2)
    cc_3 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 39, 5))
    counters.add(cc_3)
    cc_4 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 49, 5))
    counters.add(cc_4)
    cc_5 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/units.xsd', 41, 5))
    counters.add(cc_5)
    cc_6 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/units.xsd', 42, 5))
    counters.add(cc_6)
    cc_7 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/units.xsd', 43, 5))
    counters.add(cc_7)
    cc_8 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/units.xsd', 122, 5))
    counters.add(cc_8)
    states = []
    final_update = None
    symbol = pyxb.binding.content.ElementUse(ConventionalUnitType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'metaDataProperty')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 35, 5))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(ConventionalUnitType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'description')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 36, 5))
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(ConventionalUnitType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'descriptionReference')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 37, 5))
    st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(ConventionalUnitType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'identifier')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 38, 5))
    st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_3)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(ConventionalUnitType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'name')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 39, 5))
    st_4 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_4)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(ConventionalUnitType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'remarks')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 49, 5))
    st_5 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_5)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(ConventionalUnitType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'quantityType')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/units.xsd', 41, 5))
    st_6 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_6)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(ConventionalUnitType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'quantityTypeReference')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/units.xsd', 42, 5))
    st_7 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_7)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(ConventionalUnitType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'catalogSymbol')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/units.xsd', 43, 5))
    st_8 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_8)
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(ConventionalUnitType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'conversionToPreferredUnit')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/units.xsd', 119, 6))
    st_9 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_9)
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(ConventionalUnitType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'roughConversionToPreferredUnit')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/units.xsd', 120, 6))
    st_10 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_10)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_8, False))
    symbol = pyxb.binding.content.ElementUse(ConventionalUnitType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'derivationUnitTerm')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/units.xsd', 122, 5))
    st_11 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_11)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_1, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_1, False) ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_2, True) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_2, False) ]))
    st_2._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
         ]))
    transitions.append(fac.Transition(st_5, [
         ]))
    transitions.append(fac.Transition(st_6, [
         ]))
    transitions.append(fac.Transition(st_7, [
         ]))
    transitions.append(fac.Transition(st_8, [
         ]))
    transitions.append(fac.Transition(st_9, [
         ]))
    transitions.append(fac.Transition(st_10, [
         ]))
    st_3._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_3, True) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_8, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_9, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_10, [
        fac.UpdateInstruction(cc_3, False) ]))
    st_4._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_4, True) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_4, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_4, False) ]))
    transitions.append(fac.Transition(st_8, [
        fac.UpdateInstruction(cc_4, False) ]))
    transitions.append(fac.Transition(st_9, [
        fac.UpdateInstruction(cc_4, False) ]))
    transitions.append(fac.Transition(st_10, [
        fac.UpdateInstruction(cc_4, False) ]))
    st_5._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_5, True) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_5, False) ]))
    transitions.append(fac.Transition(st_8, [
        fac.UpdateInstruction(cc_5, False) ]))
    transitions.append(fac.Transition(st_9, [
        fac.UpdateInstruction(cc_5, False) ]))
    transitions.append(fac.Transition(st_10, [
        fac.UpdateInstruction(cc_5, False) ]))
    st_6._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_6, True) ]))
    transitions.append(fac.Transition(st_8, [
        fac.UpdateInstruction(cc_6, False) ]))
    transitions.append(fac.Transition(st_9, [
        fac.UpdateInstruction(cc_6, False) ]))
    transitions.append(fac.Transition(st_10, [
        fac.UpdateInstruction(cc_6, False) ]))
    st_7._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_8, [
        fac.UpdateInstruction(cc_7, True) ]))
    transitions.append(fac.Transition(st_9, [
        fac.UpdateInstruction(cc_7, False) ]))
    transitions.append(fac.Transition(st_10, [
        fac.UpdateInstruction(cc_7, False) ]))
    st_8._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_11, [
         ]))
    st_9._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_11, [
         ]))
    st_10._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_11, [
        fac.UpdateInstruction(cc_8, True) ]))
    st_11._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
ConventionalUnitType._Automaton = _BuildAutomaton_537()




def _BuildAutomaton_538 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_538
    del _BuildAutomaton_538
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 102, 5))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 103, 5))
    counters.add(cc_1)
    cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 104, 5))
    counters.add(cc_2)
    cc_3 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 106, 5))
    counters.add(cc_3)
    cc_4 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 107, 5))
    counters.add(cc_4)
    cc_5 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 108, 5))
    counters.add(cc_5)
    cc_6 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 110, 5))
    counters.add(cc_6)
    states = []
    final_update = None
    symbol = pyxb.binding.content.ElementUse(AbstractGeneralConversionType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'metaDataProperty')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 102, 5))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(AbstractGeneralConversionType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'description')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 103, 5))
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(AbstractGeneralConversionType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'descriptionReference')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 104, 5))
    st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(AbstractGeneralConversionType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'identifier')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 105, 5))
    st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_3)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(AbstractGeneralConversionType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'name')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 106, 5))
    st_4 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_4)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(AbstractGeneralConversionType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'remarks')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 107, 5))
    st_5 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_5)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(AbstractGeneralConversionType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'domainOfValidity')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 108, 5))
    st_6 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_6)
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(AbstractGeneralConversionType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'scope')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 109, 5))
    st_7 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_7)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_6, False))
    symbol = pyxb.binding.content.ElementUse(AbstractGeneralConversionType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'coordinateOperationAccuracy')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 110, 5))
    st_8 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_8)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_1, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_1, False) ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_2, True) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_2, False) ]))
    st_2._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
         ]))
    transitions.append(fac.Transition(st_5, [
         ]))
    transitions.append(fac.Transition(st_6, [
         ]))
    transitions.append(fac.Transition(st_7, [
         ]))
    st_3._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_3, True) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_3, False) ]))
    st_4._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_4, True) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_4, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_4, False) ]))
    st_5._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_5, True) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_5, False) ]))
    st_6._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_7, [
         ]))
    transitions.append(fac.Transition(st_8, [
         ]))
    st_7._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_8, [
        fac.UpdateInstruction(cc_6, True) ]))
    st_8._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
AbstractGeneralConversionType._Automaton = _BuildAutomaton_538()




def _BuildAutomaton_539 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_539
    del _BuildAutomaton_539
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 135, 5))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 136, 5))
    counters.add(cc_1)
    cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 137, 5))
    counters.add(cc_2)
    cc_3 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 139, 5))
    counters.add(cc_3)
    cc_4 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 140, 5))
    counters.add(cc_4)
    cc_5 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 141, 5))
    counters.add(cc_5)
    cc_6 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 144, 5))
    counters.add(cc_6)
    states = []
    final_update = None
    symbol = pyxb.binding.content.ElementUse(AbstractGeneralTransformationType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'metaDataProperty')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 135, 5))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(AbstractGeneralTransformationType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'description')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 136, 5))
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(AbstractGeneralTransformationType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'descriptionReference')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 137, 5))
    st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(AbstractGeneralTransformationType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'identifier')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 138, 5))
    st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_3)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(AbstractGeneralTransformationType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'name')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 139, 5))
    st_4 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_4)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(AbstractGeneralTransformationType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'remarks')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 140, 5))
    st_5 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_5)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(AbstractGeneralTransformationType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'domainOfValidity')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 141, 5))
    st_6 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_6)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(AbstractGeneralTransformationType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'scope')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 142, 5))
    st_7 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_7)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(AbstractGeneralTransformationType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'operationVersion')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 143, 5))
    st_8 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_8)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(AbstractGeneralTransformationType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'coordinateOperationAccuracy')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 144, 5))
    st_9 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_9)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(AbstractGeneralTransformationType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'sourceCRS')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 145, 5))
    st_10 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_10)
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(AbstractGeneralTransformationType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'targetCRS')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 146, 5))
    st_11 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_11)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_1, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_1, False) ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_2, True) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_2, False) ]))
    st_2._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
         ]))
    transitions.append(fac.Transition(st_5, [
         ]))
    transitions.append(fac.Transition(st_6, [
         ]))
    transitions.append(fac.Transition(st_7, [
         ]))
    st_3._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_3, True) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_3, False) ]))
    st_4._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_4, True) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_4, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_4, False) ]))
    st_5._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_5, True) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_5, False) ]))
    st_6._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_7, [
         ]))
    transitions.append(fac.Transition(st_8, [
         ]))
    st_7._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_9, [
         ]))
    transitions.append(fac.Transition(st_10, [
         ]))
    st_8._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_9, [
        fac.UpdateInstruction(cc_6, True) ]))
    transitions.append(fac.Transition(st_10, [
        fac.UpdateInstruction(cc_6, False) ]))
    st_9._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_11, [
         ]))
    st_10._set_transitionSet(transitions)
    transitions = []
    st_11._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
AbstractGeneralTransformationType._Automaton = _BuildAutomaton_539()




ConcatenatedOperationType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'coordOperation'), CoordinateOperationPropertyType, scope=ConcatenatedOperationType, documentation='gml:coordOperation is an association role to a coordinate operation.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 176, 1)))

def _BuildAutomaton_540 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_540
    del _BuildAutomaton_540
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 35, 5))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 36, 5))
    counters.add(cc_1)
    cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 37, 5))
    counters.add(cc_2)
    cc_3 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 39, 5))
    counters.add(cc_3)
    cc_4 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 49, 5))
    counters.add(cc_4)
    cc_5 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 33, 5))
    counters.add(cc_5)
    cc_6 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 35, 5))
    counters.add(cc_6)
    cc_7 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 36, 5))
    counters.add(cc_7)
    cc_8 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 37, 5))
    counters.add(cc_8)
    cc_9 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 38, 5))
    counters.add(cc_9)
    cc_10 = fac.CounterCondition(min=2, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 170, 5))
    counters.add(cc_10)
    states = []
    final_update = None
    symbol = pyxb.binding.content.ElementUse(ConcatenatedOperationType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'metaDataProperty')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 35, 5))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(ConcatenatedOperationType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'description')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 36, 5))
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(ConcatenatedOperationType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'descriptionReference')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 37, 5))
    st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(ConcatenatedOperationType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'identifier')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 38, 5))
    st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_3)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(ConcatenatedOperationType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'name')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 39, 5))
    st_4 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_4)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(ConcatenatedOperationType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'remarks')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 49, 5))
    st_5 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_5)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(ConcatenatedOperationType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'domainOfValidity')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 33, 5))
    st_6 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_6)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(ConcatenatedOperationType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'scope')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 34, 5))
    st_7 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_7)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(ConcatenatedOperationType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'operationVersion')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 35, 5))
    st_8 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_8)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(ConcatenatedOperationType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'coordinateOperationAccuracy')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 36, 5))
    st_9 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_9)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(ConcatenatedOperationType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'sourceCRS')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 37, 5))
    st_10 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_10)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(ConcatenatedOperationType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'targetCRS')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 38, 5))
    st_11 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_11)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_10, False))
    symbol = pyxb.binding.content.ElementUse(ConcatenatedOperationType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'coordOperation')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 170, 5))
    st_12 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_12)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_1, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_1, False) ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_2, True) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_2, False) ]))
    st_2._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
         ]))
    transitions.append(fac.Transition(st_5, [
         ]))
    transitions.append(fac.Transition(st_6, [
         ]))
    transitions.append(fac.Transition(st_7, [
         ]))
    st_3._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_3, True) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_3, False) ]))
    st_4._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_4, True) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_4, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_4, False) ]))
    st_5._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_5, True) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_5, False) ]))
    st_6._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_7, [
         ]))
    transitions.append(fac.Transition(st_8, [
         ]))
    transitions.append(fac.Transition(st_9, [
         ]))
    transitions.append(fac.Transition(st_10, [
         ]))
    transitions.append(fac.Transition(st_11, [
         ]))
    transitions.append(fac.Transition(st_12, [
         ]))
    st_7._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_8, [
        fac.UpdateInstruction(cc_6, True) ]))
    transitions.append(fac.Transition(st_9, [
        fac.UpdateInstruction(cc_6, False) ]))
    transitions.append(fac.Transition(st_10, [
        fac.UpdateInstruction(cc_6, False) ]))
    transitions.append(fac.Transition(st_11, [
        fac.UpdateInstruction(cc_6, False) ]))
    transitions.append(fac.Transition(st_12, [
        fac.UpdateInstruction(cc_6, False) ]))
    st_8._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_9, [
        fac.UpdateInstruction(cc_7, True) ]))
    transitions.append(fac.Transition(st_10, [
        fac.UpdateInstruction(cc_7, False) ]))
    transitions.append(fac.Transition(st_11, [
        fac.UpdateInstruction(cc_7, False) ]))
    transitions.append(fac.Transition(st_12, [
        fac.UpdateInstruction(cc_7, False) ]))
    st_9._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_10, [
        fac.UpdateInstruction(cc_8, True) ]))
    transitions.append(fac.Transition(st_11, [
        fac.UpdateInstruction(cc_8, False) ]))
    transitions.append(fac.Transition(st_12, [
        fac.UpdateInstruction(cc_8, False) ]))
    st_10._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_11, [
        fac.UpdateInstruction(cc_9, True) ]))
    transitions.append(fac.Transition(st_12, [
        fac.UpdateInstruction(cc_9, False) ]))
    st_11._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_12, [
        fac.UpdateInstruction(cc_10, True) ]))
    st_12._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
ConcatenatedOperationType._Automaton = _BuildAutomaton_540()




PassThroughOperationType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'coordOperation'), CoordinateOperationPropertyType, scope=PassThroughOperationType, documentation='gml:coordOperation is an association role to a coordinate operation.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 176, 1)))

PassThroughOperationType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'modifiedCoordinate'), pyxb.binding.datatypes.positiveInteger, scope=PassThroughOperationType, documentation='gml:modifiedCoordinate is a positive integer defining a position in a coordinate tuple.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 207, 1)))

def _BuildAutomaton_541 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_541
    del _BuildAutomaton_541
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 35, 5))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 36, 5))
    counters.add(cc_1)
    cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 37, 5))
    counters.add(cc_2)
    cc_3 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 39, 5))
    counters.add(cc_3)
    cc_4 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 49, 5))
    counters.add(cc_4)
    cc_5 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 33, 5))
    counters.add(cc_5)
    cc_6 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 35, 5))
    counters.add(cc_6)
    cc_7 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 36, 5))
    counters.add(cc_7)
    cc_8 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 37, 5))
    counters.add(cc_8)
    cc_9 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 38, 5))
    counters.add(cc_9)
    states = []
    final_update = None
    symbol = pyxb.binding.content.ElementUse(PassThroughOperationType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'metaDataProperty')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 35, 5))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(PassThroughOperationType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'description')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 36, 5))
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(PassThroughOperationType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'descriptionReference')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 37, 5))
    st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(PassThroughOperationType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'identifier')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 38, 5))
    st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_3)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(PassThroughOperationType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'name')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 39, 5))
    st_4 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_4)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(PassThroughOperationType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'remarks')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 49, 5))
    st_5 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_5)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(PassThroughOperationType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'domainOfValidity')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 33, 5))
    st_6 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_6)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(PassThroughOperationType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'scope')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 34, 5))
    st_7 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_7)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(PassThroughOperationType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'operationVersion')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 35, 5))
    st_8 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_8)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(PassThroughOperationType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'coordinateOperationAccuracy')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 36, 5))
    st_9 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_9)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(PassThroughOperationType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'sourceCRS')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 37, 5))
    st_10 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_10)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(PassThroughOperationType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'targetCRS')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 38, 5))
    st_11 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_11)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(PassThroughOperationType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'modifiedCoordinate')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 200, 5))
    st_12 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_12)
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(PassThroughOperationType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'coordOperation')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 201, 5))
    st_13 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_13)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_1, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_1, False) ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_2, True) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_2, False) ]))
    st_2._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
         ]))
    transitions.append(fac.Transition(st_5, [
         ]))
    transitions.append(fac.Transition(st_6, [
         ]))
    transitions.append(fac.Transition(st_7, [
         ]))
    st_3._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_3, True) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_3, False) ]))
    st_4._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_4, True) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_4, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_4, False) ]))
    st_5._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_5, True) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_5, False) ]))
    st_6._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_7, [
         ]))
    transitions.append(fac.Transition(st_8, [
         ]))
    transitions.append(fac.Transition(st_9, [
         ]))
    transitions.append(fac.Transition(st_10, [
         ]))
    transitions.append(fac.Transition(st_11, [
         ]))
    transitions.append(fac.Transition(st_12, [
         ]))
    st_7._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_8, [
        fac.UpdateInstruction(cc_6, True) ]))
    transitions.append(fac.Transition(st_9, [
        fac.UpdateInstruction(cc_6, False) ]))
    transitions.append(fac.Transition(st_10, [
        fac.UpdateInstruction(cc_6, False) ]))
    transitions.append(fac.Transition(st_11, [
        fac.UpdateInstruction(cc_6, False) ]))
    transitions.append(fac.Transition(st_12, [
        fac.UpdateInstruction(cc_6, False) ]))
    st_8._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_9, [
        fac.UpdateInstruction(cc_7, True) ]))
    transitions.append(fac.Transition(st_10, [
        fac.UpdateInstruction(cc_7, False) ]))
    transitions.append(fac.Transition(st_11, [
        fac.UpdateInstruction(cc_7, False) ]))
    transitions.append(fac.Transition(st_12, [
        fac.UpdateInstruction(cc_7, False) ]))
    st_9._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_10, [
        fac.UpdateInstruction(cc_8, True) ]))
    transitions.append(fac.Transition(st_11, [
        fac.UpdateInstruction(cc_8, False) ]))
    transitions.append(fac.Transition(st_12, [
        fac.UpdateInstruction(cc_8, False) ]))
    st_10._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_11, [
        fac.UpdateInstruction(cc_9, True) ]))
    transitions.append(fac.Transition(st_12, [
        fac.UpdateInstruction(cc_9, False) ]))
    st_11._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_12, [
         ]))
    transitions.append(fac.Transition(st_13, [
         ]))
    st_12._set_transitionSet(transitions)
    transitions = []
    st_13._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
PassThroughOperationType._Automaton = _BuildAutomaton_541()




def _BuildAutomaton_542 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_542
    del _BuildAutomaton_542
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 35, 5))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 36, 5))
    counters.add(cc_1)
    cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 37, 5))
    counters.add(cc_2)
    cc_3 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 39, 5))
    counters.add(cc_3)
    cc_4 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 49, 5))
    counters.add(cc_4)
    cc_5 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 455, 5))
    counters.add(cc_5)
    states = []
    final_update = None
    symbol = pyxb.binding.content.ElementUse(OperationParameterType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'metaDataProperty')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 35, 5))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(OperationParameterType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'description')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 36, 5))
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(OperationParameterType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'descriptionReference')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 37, 5))
    st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(OperationParameterType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'identifier')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 38, 5))
    st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_3)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_3, False))
    symbol = pyxb.binding.content.ElementUse(OperationParameterType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'name')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 39, 5))
    st_4 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_4)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_4, False))
    symbol = pyxb.binding.content.ElementUse(OperationParameterType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'remarks')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 49, 5))
    st_5 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_5)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_5, False))
    symbol = pyxb.binding.content.ElementUse(OperationParameterType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'minimumOccurs')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 455, 5))
    st_6 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_6)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_1, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_1, False) ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_2, True) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_2, False) ]))
    st_2._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
         ]))
    transitions.append(fac.Transition(st_5, [
         ]))
    transitions.append(fac.Transition(st_6, [
         ]))
    st_3._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_3, True) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_3, False) ]))
    st_4._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_4, True) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_4, False) ]))
    st_5._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_5, True) ]))
    st_6._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
OperationParameterType._Automaton = _BuildAutomaton_542()




OperationParameterGroupType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'parameter'), AbstractGeneralOperationParameterPropertyType, scope=OperationParameterGroupType, documentation='gml:parameter is an association to an operation parameter or parameter group.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 432, 1)))

OperationParameterGroupType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'maximumOccurs'), pyxb.binding.datatypes.positiveInteger, scope=OperationParameterGroupType, documentation='gml:maximumOccurs is the maximum number of times that values for this parameter group may be included. If this attribute is omitted, the maximum number shall be one.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 511, 1)))

def _BuildAutomaton_543 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_543
    del _BuildAutomaton_543
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 35, 5))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 36, 5))
    counters.add(cc_1)
    cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 37, 5))
    counters.add(cc_2)
    cc_3 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 39, 5))
    counters.add(cc_3)
    cc_4 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 49, 5))
    counters.add(cc_4)
    cc_5 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 455, 5))
    counters.add(cc_5)
    cc_6 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 505, 5))
    counters.add(cc_6)
    cc_7 = fac.CounterCondition(min=2, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 506, 5))
    counters.add(cc_7)
    states = []
    final_update = None
    symbol = pyxb.binding.content.ElementUse(OperationParameterGroupType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'metaDataProperty')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 35, 5))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(OperationParameterGroupType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'description')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 36, 5))
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(OperationParameterGroupType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'descriptionReference')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 37, 5))
    st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(OperationParameterGroupType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'identifier')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 38, 5))
    st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_3)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(OperationParameterGroupType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'name')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 39, 5))
    st_4 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_4)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(OperationParameterGroupType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'remarks')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 49, 5))
    st_5 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_5)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(OperationParameterGroupType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'minimumOccurs')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 455, 5))
    st_6 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_6)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(OperationParameterGroupType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'maximumOccurs')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 505, 5))
    st_7 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_7)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_7, False))
    symbol = pyxb.binding.content.ElementUse(OperationParameterGroupType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'parameter')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 506, 5))
    st_8 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_8)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_1, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_1, False) ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_2, True) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_2, False) ]))
    st_2._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
         ]))
    transitions.append(fac.Transition(st_5, [
         ]))
    transitions.append(fac.Transition(st_6, [
         ]))
    transitions.append(fac.Transition(st_7, [
         ]))
    transitions.append(fac.Transition(st_8, [
         ]))
    st_3._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_3, True) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_8, [
        fac.UpdateInstruction(cc_3, False) ]))
    st_4._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_4, True) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_4, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_4, False) ]))
    transitions.append(fac.Transition(st_8, [
        fac.UpdateInstruction(cc_4, False) ]))
    st_5._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_5, True) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_5, False) ]))
    transitions.append(fac.Transition(st_8, [
        fac.UpdateInstruction(cc_5, False) ]))
    st_6._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_6, True) ]))
    transitions.append(fac.Transition(st_8, [
        fac.UpdateInstruction(cc_6, False) ]))
    st_7._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_8, [
        fac.UpdateInstruction(cc_7, True) ]))
    st_8._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
OperationParameterGroupType._Automaton = _BuildAutomaton_543()




AbstractGeneralDerivedCRSType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'conversion'), GeneralConversionPropertyType, scope=AbstractGeneralDerivedCRSType, documentation='gml:conversion is an association role to the coordinate conversion used to define the derived CRS.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateReferenceSystems.xsd', 46, 1)))

def _BuildAutomaton_544 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_544
    del _BuildAutomaton_544
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 35, 5))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 36, 5))
    counters.add(cc_1)
    cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 37, 5))
    counters.add(cc_2)
    cc_3 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 39, 5))
    counters.add(cc_3)
    cc_4 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 49, 5))
    counters.add(cc_4)
    cc_5 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/referenceSystems.xsd', 39, 5))
    counters.add(cc_5)
    states = []
    final_update = None
    symbol = pyxb.binding.content.ElementUse(AbstractGeneralDerivedCRSType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'metaDataProperty')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 35, 5))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(AbstractGeneralDerivedCRSType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'description')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 36, 5))
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(AbstractGeneralDerivedCRSType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'descriptionReference')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 37, 5))
    st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(AbstractGeneralDerivedCRSType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'identifier')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 38, 5))
    st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_3)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(AbstractGeneralDerivedCRSType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'name')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 39, 5))
    st_4 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_4)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(AbstractGeneralDerivedCRSType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'remarks')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 49, 5))
    st_5 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_5)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(AbstractGeneralDerivedCRSType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'domainOfValidity')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/referenceSystems.xsd', 39, 5))
    st_6 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_6)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(AbstractGeneralDerivedCRSType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'scope')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/referenceSystems.xsd', 40, 5))
    st_7 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_7)
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(AbstractGeneralDerivedCRSType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'conversion')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateReferenceSystems.xsd', 41, 5))
    st_8 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_8)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_1, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_1, False) ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_2, True) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_2, False) ]))
    st_2._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
         ]))
    transitions.append(fac.Transition(st_5, [
         ]))
    transitions.append(fac.Transition(st_6, [
         ]))
    transitions.append(fac.Transition(st_7, [
         ]))
    st_3._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_3, True) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_3, False) ]))
    st_4._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_4, True) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_4, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_4, False) ]))
    st_5._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_5, True) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_5, False) ]))
    st_6._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_7, [
         ]))
    transitions.append(fac.Transition(st_8, [
         ]))
    st_7._set_transitionSet(transitions)
    transitions = []
    st_8._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
AbstractGeneralDerivedCRSType._Automaton = _BuildAutomaton_544()




CompoundCRSType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'componentReferenceSystem'), SingleCRSPropertyType, scope=CompoundCRSType, documentation='The gml:componentReferenceSystem elements are an ordered sequence of associations to all the component coordinate reference systems included in this compound coordinate reference system. The gml:AggregationAttributeGroup should be used to specify that the gml:componentReferenceSystem properties are ordered.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateReferenceSystems.xsd', 66, 1)))

def _BuildAutomaton_545 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_545
    del _BuildAutomaton_545
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 35, 5))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 36, 5))
    counters.add(cc_1)
    cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 37, 5))
    counters.add(cc_2)
    cc_3 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 39, 5))
    counters.add(cc_3)
    cc_4 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 49, 5))
    counters.add(cc_4)
    cc_5 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/referenceSystems.xsd', 39, 5))
    counters.add(cc_5)
    cc_6 = fac.CounterCondition(min=2, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateReferenceSystems.xsd', 60, 5))
    counters.add(cc_6)
    states = []
    final_update = None
    symbol = pyxb.binding.content.ElementUse(CompoundCRSType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'metaDataProperty')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 35, 5))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(CompoundCRSType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'description')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 36, 5))
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(CompoundCRSType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'descriptionReference')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 37, 5))
    st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(CompoundCRSType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'identifier')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 38, 5))
    st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_3)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(CompoundCRSType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'name')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 39, 5))
    st_4 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_4)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(CompoundCRSType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'remarks')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 49, 5))
    st_5 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_5)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(CompoundCRSType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'domainOfValidity')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/referenceSystems.xsd', 39, 5))
    st_6 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_6)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(CompoundCRSType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'scope')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/referenceSystems.xsd', 40, 5))
    st_7 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_7)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_6, False))
    symbol = pyxb.binding.content.ElementUse(CompoundCRSType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'componentReferenceSystem')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateReferenceSystems.xsd', 60, 5))
    st_8 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_8)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_1, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_1, False) ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_2, True) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_2, False) ]))
    st_2._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
         ]))
    transitions.append(fac.Transition(st_5, [
         ]))
    transitions.append(fac.Transition(st_6, [
         ]))
    transitions.append(fac.Transition(st_7, [
         ]))
    st_3._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_3, True) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_3, False) ]))
    st_4._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_4, True) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_4, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_4, False) ]))
    st_5._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_5, True) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_5, False) ]))
    st_6._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_7, [
         ]))
    transitions.append(fac.Transition(st_8, [
         ]))
    st_7._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_8, [
        fac.UpdateInstruction(cc_6, True) ]))
    st_8._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
CompoundCRSType._Automaton = _BuildAutomaton_545()




GeodeticCRSType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'ellipsoidalCS'), EllipsoidalCSPropertyType, scope=GeodeticCRSType, documentation='gml:ellipsoidalCS is an association role to the ellipsoidal coordinate system used by this CRS.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateReferenceSystems.xsd', 98, 1)))

GeodeticCRSType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'cartesianCS'), CartesianCSPropertyType, scope=GeodeticCRSType, documentation='gml:cartesianCS is an association role to the Cartesian coordinate system used by this CRS.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateReferenceSystems.xsd', 103, 1)))

GeodeticCRSType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'sphericalCS'), SphericalCSPropertyType, scope=GeodeticCRSType, documentation='gml:sphericalCS is an association role to the spherical coordinate system used by this CRS.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateReferenceSystems.xsd', 108, 1)))

GeodeticCRSType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'geodeticDatum'), GeodeticDatumPropertyType, scope=GeodeticCRSType, documentation='gml:geodeticDatum is an association role to the geodetic datum used by this CRS.\n', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateReferenceSystems.xsd', 113, 1)))

def _BuildAutomaton_546 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_546
    del _BuildAutomaton_546
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 35, 5))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 36, 5))
    counters.add(cc_1)
    cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 37, 5))
    counters.add(cc_2)
    cc_3 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 39, 5))
    counters.add(cc_3)
    cc_4 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 49, 5))
    counters.add(cc_4)
    cc_5 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/referenceSystems.xsd', 39, 5))
    counters.add(cc_5)
    states = []
    final_update = None
    symbol = pyxb.binding.content.ElementUse(GeodeticCRSType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'metaDataProperty')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 35, 5))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(GeodeticCRSType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'description')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 36, 5))
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(GeodeticCRSType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'descriptionReference')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 37, 5))
    st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(GeodeticCRSType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'identifier')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 38, 5))
    st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_3)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(GeodeticCRSType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'name')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 39, 5))
    st_4 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_4)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(GeodeticCRSType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'remarks')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 49, 5))
    st_5 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_5)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(GeodeticCRSType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'domainOfValidity')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/referenceSystems.xsd', 39, 5))
    st_6 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_6)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(GeodeticCRSType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'scope')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/referenceSystems.xsd', 40, 5))
    st_7 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_7)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(GeodeticCRSType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'ellipsoidalCS')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateReferenceSystems.xsd', 89, 6))
    st_8 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_8)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(GeodeticCRSType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'cartesianCS')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateReferenceSystems.xsd', 90, 6))
    st_9 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_9)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(GeodeticCRSType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'sphericalCS')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateReferenceSystems.xsd', 91, 6))
    st_10 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_10)
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(GeodeticCRSType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'geodeticDatum')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateReferenceSystems.xsd', 93, 5))
    st_11 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_11)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_1, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_1, False) ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_2, True) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_2, False) ]))
    st_2._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
         ]))
    transitions.append(fac.Transition(st_5, [
         ]))
    transitions.append(fac.Transition(st_6, [
         ]))
    transitions.append(fac.Transition(st_7, [
         ]))
    st_3._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_3, True) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_3, False) ]))
    st_4._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_4, True) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_4, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_4, False) ]))
    st_5._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_5, True) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_5, False) ]))
    st_6._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_7, [
         ]))
    transitions.append(fac.Transition(st_8, [
         ]))
    transitions.append(fac.Transition(st_9, [
         ]))
    transitions.append(fac.Transition(st_10, [
         ]))
    st_7._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_11, [
         ]))
    st_8._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_11, [
         ]))
    st_9._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_11, [
         ]))
    st_10._set_transitionSet(transitions)
    transitions = []
    st_11._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
GeodeticCRSType._Automaton = _BuildAutomaton_546()




VerticalCRSType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'verticalCS'), VerticalCSPropertyType, scope=VerticalCRSType, documentation='gml:verticalCS is an association role to the vertical coordinate system used by this CRS.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateReferenceSystems.xsd', 143, 1)))

VerticalCRSType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'verticalDatum'), VerticalDatumPropertyType, scope=VerticalCRSType, documentation='gml:verticalDatum is an association role to the vertical datum used by this CRS.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateReferenceSystems.xsd', 148, 1)))

def _BuildAutomaton_547 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_547
    del _BuildAutomaton_547
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 35, 5))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 36, 5))
    counters.add(cc_1)
    cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 37, 5))
    counters.add(cc_2)
    cc_3 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 39, 5))
    counters.add(cc_3)
    cc_4 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 49, 5))
    counters.add(cc_4)
    cc_5 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/referenceSystems.xsd', 39, 5))
    counters.add(cc_5)
    states = []
    final_update = None
    symbol = pyxb.binding.content.ElementUse(VerticalCRSType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'metaDataProperty')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 35, 5))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(VerticalCRSType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'description')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 36, 5))
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(VerticalCRSType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'descriptionReference')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 37, 5))
    st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(VerticalCRSType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'identifier')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 38, 5))
    st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_3)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(VerticalCRSType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'name')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 39, 5))
    st_4 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_4)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(VerticalCRSType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'remarks')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 49, 5))
    st_5 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_5)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(VerticalCRSType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'domainOfValidity')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/referenceSystems.xsd', 39, 5))
    st_6 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_6)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(VerticalCRSType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'scope')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/referenceSystems.xsd', 40, 5))
    st_7 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_7)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(VerticalCRSType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'verticalCS')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateReferenceSystems.xsd', 137, 5))
    st_8 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_8)
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(VerticalCRSType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'verticalDatum')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateReferenceSystems.xsd', 138, 5))
    st_9 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_9)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_1, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_1, False) ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_2, True) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_2, False) ]))
    st_2._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
         ]))
    transitions.append(fac.Transition(st_5, [
         ]))
    transitions.append(fac.Transition(st_6, [
         ]))
    transitions.append(fac.Transition(st_7, [
         ]))
    st_3._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_3, True) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_3, False) ]))
    st_4._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_4, True) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_4, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_4, False) ]))
    st_5._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_5, True) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_5, False) ]))
    st_6._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_7, [
         ]))
    transitions.append(fac.Transition(st_8, [
         ]))
    st_7._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_9, [
         ]))
    st_8._set_transitionSet(transitions)
    transitions = []
    st_9._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
VerticalCRSType._Automaton = _BuildAutomaton_547()




EngineeringCRSType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'cartesianCS'), CartesianCSPropertyType, scope=EngineeringCRSType, documentation='gml:cartesianCS is an association role to the Cartesian coordinate system used by this CRS.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateReferenceSystems.xsd', 103, 1)))

EngineeringCRSType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'sphericalCS'), SphericalCSPropertyType, scope=EngineeringCRSType, documentation='gml:sphericalCS is an association role to the spherical coordinate system used by this CRS.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateReferenceSystems.xsd', 108, 1)))

EngineeringCRSType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'coordinateSystem'), CoordinateSystemPropertyType, scope=EngineeringCRSType, documentation='An association role to the coordinate system used by this CRS.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateReferenceSystems.xsd', 220, 1)))

EngineeringCRSType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'cylindricalCS'), CylindricalCSPropertyType, scope=EngineeringCRSType, documentation='gml:cylindricalCS is an association role to the cylindrical coordinate system used by this CRS.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateReferenceSystems.xsd', 264, 1)))

EngineeringCRSType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'linearCS'), LinearCSPropertyType, scope=EngineeringCRSType, documentation='gml:linearCS is an association role to the linear coordinate system used by this CRS.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateReferenceSystems.xsd', 269, 1)))

EngineeringCRSType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'polarCS'), PolarCSPropertyType, scope=EngineeringCRSType, documentation='gml:polarCS is an association role to the polar coordinate system used by this CRS.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateReferenceSystems.xsd', 274, 1)))

EngineeringCRSType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'userDefinedCS'), UserDefinedCSPropertyType, scope=EngineeringCRSType, documentation='gml:userDefinedCS is an association role to the user defined coordinate system used by this CRS.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateReferenceSystems.xsd', 279, 1)))

EngineeringCRSType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'engineeringDatum'), EngineeringDatumPropertyType, scope=EngineeringCRSType, documentation='gml:engineeringDatum is an association role to the engineering datum used by this CRS.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateReferenceSystems.xsd', 284, 1)))

EngineeringCRSType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'affineCS'), AffineCSPropertyType, scope=EngineeringCRSType, documentation='gml:affineCS is an association role to the affine coordinate system used by this CRS.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateReferenceSystems.xsd', 317, 1)))

def _BuildAutomaton_548 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_548
    del _BuildAutomaton_548
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 35, 5))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 36, 5))
    counters.add(cc_1)
    cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 37, 5))
    counters.add(cc_2)
    cc_3 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 39, 5))
    counters.add(cc_3)
    cc_4 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 49, 5))
    counters.add(cc_4)
    cc_5 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/referenceSystems.xsd', 39, 5))
    counters.add(cc_5)
    states = []
    final_update = None
    symbol = pyxb.binding.content.ElementUse(EngineeringCRSType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'metaDataProperty')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 35, 5))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(EngineeringCRSType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'description')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 36, 5))
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(EngineeringCRSType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'descriptionReference')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 37, 5))
    st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(EngineeringCRSType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'identifier')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 38, 5))
    st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_3)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(EngineeringCRSType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'name')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 39, 5))
    st_4 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_4)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(EngineeringCRSType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'remarks')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 49, 5))
    st_5 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_5)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(EngineeringCRSType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'domainOfValidity')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/referenceSystems.xsd', 39, 5))
    st_6 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_6)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(EngineeringCRSType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'scope')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/referenceSystems.xsd', 40, 5))
    st_7 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_7)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(EngineeringCRSType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'affineCS')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateReferenceSystems.xsd', 246, 6))
    st_8 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_8)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(EngineeringCRSType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'cartesianCS')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateReferenceSystems.xsd', 247, 6))
    st_9 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_9)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(EngineeringCRSType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'cylindricalCS')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateReferenceSystems.xsd', 248, 6))
    st_10 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_10)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(EngineeringCRSType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'linearCS')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateReferenceSystems.xsd', 249, 6))
    st_11 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_11)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(EngineeringCRSType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'polarCS')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateReferenceSystems.xsd', 250, 6))
    st_12 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_12)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(EngineeringCRSType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'sphericalCS')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateReferenceSystems.xsd', 251, 6))
    st_13 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_13)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(EngineeringCRSType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'userDefinedCS')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateReferenceSystems.xsd', 252, 6))
    st_14 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_14)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(EngineeringCRSType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'coordinateSystem')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateReferenceSystems.xsd', 253, 6))
    st_15 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_15)
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(EngineeringCRSType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'engineeringDatum')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateReferenceSystems.xsd', 259, 5))
    st_16 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_16)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_1, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_1, False) ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_2, True) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_2, False) ]))
    st_2._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
         ]))
    transitions.append(fac.Transition(st_5, [
         ]))
    transitions.append(fac.Transition(st_6, [
         ]))
    transitions.append(fac.Transition(st_7, [
         ]))
    st_3._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_3, True) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_3, False) ]))
    st_4._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_4, True) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_4, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_4, False) ]))
    st_5._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_5, True) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_5, False) ]))
    st_6._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_7, [
         ]))
    transitions.append(fac.Transition(st_8, [
         ]))
    transitions.append(fac.Transition(st_9, [
         ]))
    transitions.append(fac.Transition(st_10, [
         ]))
    transitions.append(fac.Transition(st_11, [
         ]))
    transitions.append(fac.Transition(st_12, [
         ]))
    transitions.append(fac.Transition(st_13, [
         ]))
    transitions.append(fac.Transition(st_14, [
         ]))
    transitions.append(fac.Transition(st_15, [
         ]))
    st_7._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_16, [
         ]))
    st_8._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_16, [
         ]))
    st_9._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_16, [
         ]))
    st_10._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_16, [
         ]))
    st_11._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_16, [
         ]))
    st_12._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_16, [
         ]))
    st_13._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_16, [
         ]))
    st_14._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_16, [
         ]))
    st_15._set_transitionSet(transitions)
    transitions = []
    st_16._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
EngineeringCRSType._Automaton = _BuildAutomaton_548()




ImageCRSType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'cartesianCS'), CartesianCSPropertyType, scope=ImageCRSType, documentation='gml:cartesianCS is an association role to the Cartesian coordinate system used by this CRS.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateReferenceSystems.xsd', 103, 1)))

ImageCRSType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'affineCS'), AffineCSPropertyType, scope=ImageCRSType, documentation='gml:affineCS is an association role to the affine coordinate system used by this CRS.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateReferenceSystems.xsd', 317, 1)))

ImageCRSType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'imageDatum'), ImageDatumPropertyType, scope=ImageCRSType, documentation='gml:imageDatum is an association role to the image datum used by this CRS.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateReferenceSystems.xsd', 322, 1)))

ImageCRSType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'usesObliqueCartesianCS'), ObliqueCartesianCSPropertyType, scope=ImageCRSType, documentation='', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 421, 1)))

def _BuildAutomaton_549 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_549
    del _BuildAutomaton_549
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 35, 5))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 36, 5))
    counters.add(cc_1)
    cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 37, 5))
    counters.add(cc_2)
    cc_3 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 39, 5))
    counters.add(cc_3)
    cc_4 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 49, 5))
    counters.add(cc_4)
    cc_5 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/referenceSystems.xsd', 39, 5))
    counters.add(cc_5)
    states = []
    final_update = None
    symbol = pyxb.binding.content.ElementUse(ImageCRSType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'metaDataProperty')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 35, 5))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(ImageCRSType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'description')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 36, 5))
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(ImageCRSType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'descriptionReference')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 37, 5))
    st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(ImageCRSType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'identifier')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 38, 5))
    st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_3)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(ImageCRSType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'name')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 39, 5))
    st_4 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_4)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(ImageCRSType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'remarks')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 49, 5))
    st_5 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_5)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(ImageCRSType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'domainOfValidity')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/referenceSystems.xsd', 39, 5))
    st_6 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_6)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(ImageCRSType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'scope')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/referenceSystems.xsd', 40, 5))
    st_7 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_7)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(ImageCRSType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'cartesianCS')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateReferenceSystems.xsd', 308, 6))
    st_8 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_8)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(ImageCRSType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'affineCS')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateReferenceSystems.xsd', 309, 6))
    st_9 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_9)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(ImageCRSType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'usesObliqueCartesianCS')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateReferenceSystems.xsd', 310, 6))
    st_10 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_10)
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(ImageCRSType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'imageDatum')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateReferenceSystems.xsd', 312, 5))
    st_11 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_11)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_1, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_1, False) ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_2, True) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_2, False) ]))
    st_2._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
         ]))
    transitions.append(fac.Transition(st_5, [
         ]))
    transitions.append(fac.Transition(st_6, [
         ]))
    transitions.append(fac.Transition(st_7, [
         ]))
    st_3._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_3, True) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_3, False) ]))
    st_4._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_4, True) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_4, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_4, False) ]))
    st_5._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_5, True) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_5, False) ]))
    st_6._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_7, [
         ]))
    transitions.append(fac.Transition(st_8, [
         ]))
    transitions.append(fac.Transition(st_9, [
         ]))
    transitions.append(fac.Transition(st_10, [
         ]))
    st_7._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_11, [
         ]))
    st_8._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_11, [
         ]))
    st_9._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_11, [
         ]))
    st_10._set_transitionSet(transitions)
    transitions = []
    st_11._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
ImageCRSType._Automaton = _BuildAutomaton_549()




TemporalCRSType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'timeCS'), TimeCSPropertyType, scope=TemporalCRSType, documentation='gml:timeCS is an association role to the time coordinate system used by this CRS.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateReferenceSystems.xsd', 354, 1)))

TemporalCRSType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'temporalDatum'), TemporalDatumPropertyType, scope=TemporalCRSType, documentation='gml:temporalDatum is an association role to the temporal datum used by this CRS.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateReferenceSystems.xsd', 359, 1)))

TemporalCRSType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'usesTemporalCS'), TemporalCSPropertyType, scope=TemporalCRSType, documentation='', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 436, 1)))

def _BuildAutomaton_550 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_550
    del _BuildAutomaton_550
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 35, 5))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 36, 5))
    counters.add(cc_1)
    cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 37, 5))
    counters.add(cc_2)
    cc_3 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 39, 5))
    counters.add(cc_3)
    cc_4 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 49, 5))
    counters.add(cc_4)
    cc_5 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/referenceSystems.xsd', 39, 5))
    counters.add(cc_5)
    states = []
    final_update = None
    symbol = pyxb.binding.content.ElementUse(TemporalCRSType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'metaDataProperty')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 35, 5))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(TemporalCRSType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'description')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 36, 5))
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(TemporalCRSType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'descriptionReference')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 37, 5))
    st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(TemporalCRSType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'identifier')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 38, 5))
    st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_3)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(TemporalCRSType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'name')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 39, 5))
    st_4 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_4)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(TemporalCRSType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'remarks')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 49, 5))
    st_5 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_5)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(TemporalCRSType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'domainOfValidity')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/referenceSystems.xsd', 39, 5))
    st_6 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_6)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(TemporalCRSType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'scope')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/referenceSystems.xsd', 40, 5))
    st_7 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_7)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(TemporalCRSType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'timeCS')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateReferenceSystems.xsd', 346, 6))
    st_8 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_8)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(TemporalCRSType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'usesTemporalCS')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateReferenceSystems.xsd', 347, 6))
    st_9 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_9)
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(TemporalCRSType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'temporalDatum')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateReferenceSystems.xsd', 349, 5))
    st_10 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_10)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_1, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_1, False) ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_2, True) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_2, False) ]))
    st_2._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
         ]))
    transitions.append(fac.Transition(st_5, [
         ]))
    transitions.append(fac.Transition(st_6, [
         ]))
    transitions.append(fac.Transition(st_7, [
         ]))
    st_3._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_3, True) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_3, False) ]))
    st_4._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_4, True) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_4, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_4, False) ]))
    st_5._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_5, True) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_5, False) ]))
    st_6._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_7, [
         ]))
    transitions.append(fac.Transition(st_8, [
         ]))
    transitions.append(fac.Transition(st_9, [
         ]))
    st_7._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_10, [
         ]))
    st_8._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_10, [
         ]))
    st_9._set_transitionSet(transitions)
    transitions = []
    st_10._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
TemporalCRSType._Automaton = _BuildAutomaton_550()




def _BuildAutomaton_551 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_551
    del _BuildAutomaton_551
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 35, 5))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 36, 5))
    counters.add(cc_1)
    cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 37, 5))
    counters.add(cc_2)
    cc_3 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 39, 5))
    counters.add(cc_3)
    cc_4 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 49, 5))
    counters.add(cc_4)
    states = []
    final_update = None
    symbol = pyxb.binding.content.ElementUse(EllipsoidalCSType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'metaDataProperty')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 35, 5))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(EllipsoidalCSType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'description')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 36, 5))
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(EllipsoidalCSType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'descriptionReference')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 37, 5))
    st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(EllipsoidalCSType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'identifier')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 38, 5))
    st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_3)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(EllipsoidalCSType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'name')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 39, 5))
    st_4 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_4)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(EllipsoidalCSType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'remarks')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 49, 5))
    st_5 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_5)
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(EllipsoidalCSType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'axis')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateSystems.xsd', 87, 5))
    st_6 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_6)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_1, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_1, False) ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_2, True) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_2, False) ]))
    st_2._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
         ]))
    transitions.append(fac.Transition(st_5, [
         ]))
    transitions.append(fac.Transition(st_6, [
         ]))
    st_3._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_3, True) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_3, False) ]))
    st_4._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_4, True) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_4, False) ]))
    st_5._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_6, [
         ]))
    st_6._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
EllipsoidalCSType._Automaton = _BuildAutomaton_551()




def _BuildAutomaton_552 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_552
    del _BuildAutomaton_552
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 35, 5))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 36, 5))
    counters.add(cc_1)
    cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 37, 5))
    counters.add(cc_2)
    cc_3 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 39, 5))
    counters.add(cc_3)
    cc_4 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 49, 5))
    counters.add(cc_4)
    states = []
    final_update = None
    symbol = pyxb.binding.content.ElementUse(CartesianCSType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'metaDataProperty')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 35, 5))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(CartesianCSType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'description')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 36, 5))
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(CartesianCSType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'descriptionReference')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 37, 5))
    st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(CartesianCSType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'identifier')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 38, 5))
    st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_3)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(CartesianCSType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'name')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 39, 5))
    st_4 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_4)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(CartesianCSType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'remarks')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 49, 5))
    st_5 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_5)
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(CartesianCSType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'axis')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateSystems.xsd', 87, 5))
    st_6 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_6)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_1, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_1, False) ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_2, True) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_2, False) ]))
    st_2._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
         ]))
    transitions.append(fac.Transition(st_5, [
         ]))
    transitions.append(fac.Transition(st_6, [
         ]))
    st_3._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_3, True) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_3, False) ]))
    st_4._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_4, True) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_4, False) ]))
    st_5._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_6, [
         ]))
    st_6._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
CartesianCSType._Automaton = _BuildAutomaton_552()




def _BuildAutomaton_553 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_553
    del _BuildAutomaton_553
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 35, 5))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 36, 5))
    counters.add(cc_1)
    cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 37, 5))
    counters.add(cc_2)
    cc_3 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 39, 5))
    counters.add(cc_3)
    cc_4 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 49, 5))
    counters.add(cc_4)
    states = []
    final_update = None
    symbol = pyxb.binding.content.ElementUse(VerticalCSType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'metaDataProperty')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 35, 5))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(VerticalCSType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'description')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 36, 5))
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(VerticalCSType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'descriptionReference')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 37, 5))
    st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(VerticalCSType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'identifier')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 38, 5))
    st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_3)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(VerticalCSType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'name')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 39, 5))
    st_4 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_4)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(VerticalCSType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'remarks')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 49, 5))
    st_5 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_5)
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(VerticalCSType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'axis')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateSystems.xsd', 87, 5))
    st_6 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_6)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_1, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_1, False) ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_2, True) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_2, False) ]))
    st_2._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
         ]))
    transitions.append(fac.Transition(st_5, [
         ]))
    transitions.append(fac.Transition(st_6, [
         ]))
    st_3._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_3, True) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_3, False) ]))
    st_4._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_4, True) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_4, False) ]))
    st_5._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_6, [
         ]))
    st_6._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
VerticalCSType._Automaton = _BuildAutomaton_553()




def _BuildAutomaton_554 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_554
    del _BuildAutomaton_554
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 35, 5))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 36, 5))
    counters.add(cc_1)
    cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 37, 5))
    counters.add(cc_2)
    cc_3 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 39, 5))
    counters.add(cc_3)
    cc_4 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 49, 5))
    counters.add(cc_4)
    states = []
    final_update = None
    symbol = pyxb.binding.content.ElementUse(TimeCSType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'metaDataProperty')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 35, 5))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(TimeCSType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'description')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 36, 5))
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(TimeCSType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'descriptionReference')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 37, 5))
    st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(TimeCSType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'identifier')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 38, 5))
    st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_3)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(TimeCSType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'name')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 39, 5))
    st_4 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_4)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(TimeCSType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'remarks')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 49, 5))
    st_5 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_5)
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(TimeCSType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'axis')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateSystems.xsd', 87, 5))
    st_6 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_6)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_1, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_1, False) ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_2, True) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_2, False) ]))
    st_2._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
         ]))
    transitions.append(fac.Transition(st_5, [
         ]))
    transitions.append(fac.Transition(st_6, [
         ]))
    st_3._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_3, True) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_3, False) ]))
    st_4._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_4, True) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_4, False) ]))
    st_5._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_6, [
         ]))
    st_6._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
TimeCSType._Automaton = _BuildAutomaton_554()




def _BuildAutomaton_555 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_555
    del _BuildAutomaton_555
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 35, 5))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 36, 5))
    counters.add(cc_1)
    cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 37, 5))
    counters.add(cc_2)
    cc_3 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 39, 5))
    counters.add(cc_3)
    cc_4 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 49, 5))
    counters.add(cc_4)
    states = []
    final_update = None
    symbol = pyxb.binding.content.ElementUse(LinearCSType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'metaDataProperty')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 35, 5))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(LinearCSType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'description')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 36, 5))
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(LinearCSType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'descriptionReference')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 37, 5))
    st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(LinearCSType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'identifier')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 38, 5))
    st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_3)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(LinearCSType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'name')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 39, 5))
    st_4 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_4)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(LinearCSType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'remarks')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 49, 5))
    st_5 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_5)
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(LinearCSType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'axis')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateSystems.xsd', 87, 5))
    st_6 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_6)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_1, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_1, False) ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_2, True) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_2, False) ]))
    st_2._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
         ]))
    transitions.append(fac.Transition(st_5, [
         ]))
    transitions.append(fac.Transition(st_6, [
         ]))
    st_3._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_3, True) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_3, False) ]))
    st_4._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_4, True) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_4, False) ]))
    st_5._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_6, [
         ]))
    st_6._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
LinearCSType._Automaton = _BuildAutomaton_555()




def _BuildAutomaton_556 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_556
    del _BuildAutomaton_556
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 35, 5))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 36, 5))
    counters.add(cc_1)
    cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 37, 5))
    counters.add(cc_2)
    cc_3 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 39, 5))
    counters.add(cc_3)
    cc_4 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 49, 5))
    counters.add(cc_4)
    states = []
    final_update = None
    symbol = pyxb.binding.content.ElementUse(UserDefinedCSType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'metaDataProperty')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 35, 5))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(UserDefinedCSType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'description')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 36, 5))
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(UserDefinedCSType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'descriptionReference')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 37, 5))
    st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(UserDefinedCSType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'identifier')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 38, 5))
    st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_3)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(UserDefinedCSType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'name')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 39, 5))
    st_4 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_4)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(UserDefinedCSType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'remarks')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 49, 5))
    st_5 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_5)
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(UserDefinedCSType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'axis')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateSystems.xsd', 87, 5))
    st_6 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_6)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_1, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_1, False) ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_2, True) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_2, False) ]))
    st_2._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
         ]))
    transitions.append(fac.Transition(st_5, [
         ]))
    transitions.append(fac.Transition(st_6, [
         ]))
    st_3._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_3, True) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_3, False) ]))
    st_4._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_4, True) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_4, False) ]))
    st_5._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_6, [
         ]))
    st_6._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
UserDefinedCSType._Automaton = _BuildAutomaton_556()




def _BuildAutomaton_557 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_557
    del _BuildAutomaton_557
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 35, 5))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 36, 5))
    counters.add(cc_1)
    cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 37, 5))
    counters.add(cc_2)
    cc_3 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 39, 5))
    counters.add(cc_3)
    cc_4 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 49, 5))
    counters.add(cc_4)
    states = []
    final_update = None
    symbol = pyxb.binding.content.ElementUse(SphericalCSType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'metaDataProperty')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 35, 5))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(SphericalCSType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'description')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 36, 5))
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(SphericalCSType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'descriptionReference')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 37, 5))
    st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(SphericalCSType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'identifier')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 38, 5))
    st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_3)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(SphericalCSType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'name')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 39, 5))
    st_4 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_4)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(SphericalCSType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'remarks')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 49, 5))
    st_5 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_5)
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(SphericalCSType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'axis')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateSystems.xsd', 87, 5))
    st_6 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_6)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_1, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_1, False) ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_2, True) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_2, False) ]))
    st_2._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
         ]))
    transitions.append(fac.Transition(st_5, [
         ]))
    transitions.append(fac.Transition(st_6, [
         ]))
    st_3._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_3, True) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_3, False) ]))
    st_4._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_4, True) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_4, False) ]))
    st_5._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_6, [
         ]))
    st_6._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
SphericalCSType._Automaton = _BuildAutomaton_557()




def _BuildAutomaton_558 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_558
    del _BuildAutomaton_558
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 35, 5))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 36, 5))
    counters.add(cc_1)
    cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 37, 5))
    counters.add(cc_2)
    cc_3 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 39, 5))
    counters.add(cc_3)
    cc_4 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 49, 5))
    counters.add(cc_4)
    states = []
    final_update = None
    symbol = pyxb.binding.content.ElementUse(PolarCSType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'metaDataProperty')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 35, 5))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(PolarCSType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'description')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 36, 5))
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(PolarCSType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'descriptionReference')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 37, 5))
    st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(PolarCSType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'identifier')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 38, 5))
    st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_3)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(PolarCSType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'name')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 39, 5))
    st_4 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_4)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(PolarCSType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'remarks')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 49, 5))
    st_5 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_5)
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(PolarCSType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'axis')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateSystems.xsd', 87, 5))
    st_6 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_6)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_1, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_1, False) ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_2, True) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_2, False) ]))
    st_2._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
         ]))
    transitions.append(fac.Transition(st_5, [
         ]))
    transitions.append(fac.Transition(st_6, [
         ]))
    st_3._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_3, True) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_3, False) ]))
    st_4._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_4, True) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_4, False) ]))
    st_5._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_6, [
         ]))
    st_6._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
PolarCSType._Automaton = _BuildAutomaton_558()




def _BuildAutomaton_559 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_559
    del _BuildAutomaton_559
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 35, 5))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 36, 5))
    counters.add(cc_1)
    cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 37, 5))
    counters.add(cc_2)
    cc_3 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 39, 5))
    counters.add(cc_3)
    cc_4 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 49, 5))
    counters.add(cc_4)
    states = []
    final_update = None
    symbol = pyxb.binding.content.ElementUse(CylindricalCSType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'metaDataProperty')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 35, 5))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(CylindricalCSType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'description')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 36, 5))
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(CylindricalCSType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'descriptionReference')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 37, 5))
    st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(CylindricalCSType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'identifier')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 38, 5))
    st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_3)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(CylindricalCSType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'name')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 39, 5))
    st_4 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_4)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(CylindricalCSType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'remarks')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 49, 5))
    st_5 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_5)
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(CylindricalCSType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'axis')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateSystems.xsd', 87, 5))
    st_6 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_6)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_1, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_1, False) ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_2, True) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_2, False) ]))
    st_2._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
         ]))
    transitions.append(fac.Transition(st_5, [
         ]))
    transitions.append(fac.Transition(st_6, [
         ]))
    st_3._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_3, True) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_3, False) ]))
    st_4._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_4, True) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_4, False) ]))
    st_5._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_6, [
         ]))
    st_6._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
CylindricalCSType._Automaton = _BuildAutomaton_559()




def _BuildAutomaton_560 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_560
    del _BuildAutomaton_560
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 35, 5))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 36, 5))
    counters.add(cc_1)
    cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 37, 5))
    counters.add(cc_2)
    cc_3 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 39, 5))
    counters.add(cc_3)
    cc_4 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 49, 5))
    counters.add(cc_4)
    states = []
    final_update = None
    symbol = pyxb.binding.content.ElementUse(AffineCSType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'metaDataProperty')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 35, 5))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(AffineCSType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'description')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 36, 5))
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(AffineCSType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'descriptionReference')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 37, 5))
    st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(AffineCSType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'identifier')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 38, 5))
    st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_3)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(AffineCSType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'name')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 39, 5))
    st_4 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_4)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(AffineCSType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'remarks')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 49, 5))
    st_5 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_5)
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(AffineCSType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'axis')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateSystems.xsd', 87, 5))
    st_6 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_6)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_1, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_1, False) ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_2, True) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_2, False) ]))
    st_2._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
         ]))
    transitions.append(fac.Transition(st_5, [
         ]))
    transitions.append(fac.Transition(st_6, [
         ]))
    st_3._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_3, True) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_3, False) ]))
    st_4._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_4, True) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_4, False) ]))
    st_5._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_6, [
         ]))
    st_6._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
AffineCSType._Automaton = _BuildAutomaton_560()




GeodeticDatumType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'primeMeridian'), PrimeMeridianPropertyType, scope=GeodeticDatumType, documentation='gml:primeMeridian is an association role to the prime meridian used by this geodetic datum.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/datums.xsd', 76, 1)))

GeodeticDatumType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'ellipsoid'), EllipsoidPropertyType, scope=GeodeticDatumType, documentation='gml:ellipsoid is an association role to the ellipsoid used by this geodetic datum.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/datums.xsd', 81, 1)))

def _BuildAutomaton_561 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_561
    del _BuildAutomaton_561
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 35, 5))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 36, 5))
    counters.add(cc_1)
    cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 37, 5))
    counters.add(cc_2)
    cc_3 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 39, 5))
    counters.add(cc_3)
    cc_4 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 49, 5))
    counters.add(cc_4)
    cc_5 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/datums.xsd', 30, 5))
    counters.add(cc_5)
    cc_6 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/datums.xsd', 32, 5))
    counters.add(cc_6)
    cc_7 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/datums.xsd', 33, 5))
    counters.add(cc_7)
    states = []
    final_update = None
    symbol = pyxb.binding.content.ElementUse(GeodeticDatumType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'metaDataProperty')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 35, 5))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(GeodeticDatumType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'description')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 36, 5))
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(GeodeticDatumType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'descriptionReference')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 37, 5))
    st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(GeodeticDatumType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'identifier')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 38, 5))
    st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_3)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(GeodeticDatumType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'name')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 39, 5))
    st_4 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_4)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(GeodeticDatumType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'remarks')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 49, 5))
    st_5 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_5)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(GeodeticDatumType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'domainOfValidity')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/datums.xsd', 30, 5))
    st_6 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_6)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(GeodeticDatumType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'scope')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/datums.xsd', 31, 5))
    st_7 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_7)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(GeodeticDatumType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'anchorDefinition')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/datums.xsd', 32, 5))
    st_8 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_8)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(GeodeticDatumType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'realizationEpoch')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/datums.xsd', 33, 5))
    st_9 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_9)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(GeodeticDatumType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'primeMeridian')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/datums.xsd', 70, 5))
    st_10 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_10)
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(GeodeticDatumType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'ellipsoid')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/datums.xsd', 71, 5))
    st_11 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_11)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_1, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_1, False) ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_2, True) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_2, False) ]))
    st_2._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
         ]))
    transitions.append(fac.Transition(st_5, [
         ]))
    transitions.append(fac.Transition(st_6, [
         ]))
    transitions.append(fac.Transition(st_7, [
         ]))
    st_3._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_3, True) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_3, False) ]))
    st_4._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_4, True) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_4, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_4, False) ]))
    st_5._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_5, True) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_5, False) ]))
    st_6._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_7, [
         ]))
    transitions.append(fac.Transition(st_8, [
         ]))
    transitions.append(fac.Transition(st_9, [
         ]))
    transitions.append(fac.Transition(st_10, [
         ]))
    st_7._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_8, [
        fac.UpdateInstruction(cc_6, True) ]))
    transitions.append(fac.Transition(st_9, [
        fac.UpdateInstruction(cc_6, False) ]))
    transitions.append(fac.Transition(st_10, [
        fac.UpdateInstruction(cc_6, False) ]))
    st_8._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_9, [
        fac.UpdateInstruction(cc_7, True) ]))
    transitions.append(fac.Transition(st_10, [
        fac.UpdateInstruction(cc_7, False) ]))
    st_9._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_11, [
         ]))
    st_10._set_transitionSet(transitions)
    transitions = []
    st_11._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
GeodeticDatumType._Automaton = _BuildAutomaton_561()




def _BuildAutomaton_562 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_562
    del _BuildAutomaton_562
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 35, 5))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 36, 5))
    counters.add(cc_1)
    cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 37, 5))
    counters.add(cc_2)
    cc_3 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 39, 5))
    counters.add(cc_3)
    cc_4 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 49, 5))
    counters.add(cc_4)
    cc_5 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/datums.xsd', 30, 5))
    counters.add(cc_5)
    cc_6 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/datums.xsd', 32, 5))
    counters.add(cc_6)
    cc_7 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/datums.xsd', 33, 5))
    counters.add(cc_7)
    states = []
    final_update = None
    symbol = pyxb.binding.content.ElementUse(EngineeringDatumType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'metaDataProperty')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 35, 5))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(EngineeringDatumType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'description')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 36, 5))
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(EngineeringDatumType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'descriptionReference')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 37, 5))
    st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(EngineeringDatumType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'identifier')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 38, 5))
    st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_3)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(EngineeringDatumType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'name')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 39, 5))
    st_4 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_4)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(EngineeringDatumType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'remarks')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 49, 5))
    st_5 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_5)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(EngineeringDatumType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'domainOfValidity')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/datums.xsd', 30, 5))
    st_6 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_6)
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(EngineeringDatumType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'scope')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/datums.xsd', 31, 5))
    st_7 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_7)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_6, False))
    symbol = pyxb.binding.content.ElementUse(EngineeringDatumType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'anchorDefinition')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/datums.xsd', 32, 5))
    st_8 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_8)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_7, False))
    symbol = pyxb.binding.content.ElementUse(EngineeringDatumType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'realizationEpoch')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/datums.xsd', 33, 5))
    st_9 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_9)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_1, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_1, False) ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_2, True) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_2, False) ]))
    st_2._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
         ]))
    transitions.append(fac.Transition(st_5, [
         ]))
    transitions.append(fac.Transition(st_6, [
         ]))
    transitions.append(fac.Transition(st_7, [
         ]))
    st_3._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_3, True) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_3, False) ]))
    st_4._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_4, True) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_4, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_4, False) ]))
    st_5._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_5, True) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_5, False) ]))
    st_6._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_7, [
         ]))
    transitions.append(fac.Transition(st_8, [
         ]))
    transitions.append(fac.Transition(st_9, [
         ]))
    st_7._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_8, [
        fac.UpdateInstruction(cc_6, True) ]))
    transitions.append(fac.Transition(st_9, [
        fac.UpdateInstruction(cc_6, False) ]))
    st_8._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_9, [
        fac.UpdateInstruction(cc_7, True) ]))
    st_9._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
EngineeringDatumType._Automaton = _BuildAutomaton_562()




ImageDatumType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'pixelInCell'), CodeWithAuthorityType, scope=ImageDatumType, documentation='gml:pixelInCell is a specification of the way an image grid is associated with the image data attributes. The required codeSpace attribute shall reference a source of information specifying the values and meanings of all the allowed string values for this property.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/datums.xsd', 206, 1)))

def _BuildAutomaton_563 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_563
    del _BuildAutomaton_563
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 35, 5))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 36, 5))
    counters.add(cc_1)
    cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 37, 5))
    counters.add(cc_2)
    cc_3 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 39, 5))
    counters.add(cc_3)
    cc_4 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 49, 5))
    counters.add(cc_4)
    cc_5 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/datums.xsd', 30, 5))
    counters.add(cc_5)
    cc_6 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/datums.xsd', 32, 5))
    counters.add(cc_6)
    cc_7 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/datums.xsd', 33, 5))
    counters.add(cc_7)
    states = []
    final_update = None
    symbol = pyxb.binding.content.ElementUse(ImageDatumType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'metaDataProperty')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 35, 5))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(ImageDatumType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'description')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 36, 5))
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(ImageDatumType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'descriptionReference')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 37, 5))
    st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(ImageDatumType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'identifier')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 38, 5))
    st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_3)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(ImageDatumType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'name')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 39, 5))
    st_4 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_4)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(ImageDatumType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'remarks')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 49, 5))
    st_5 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_5)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(ImageDatumType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'domainOfValidity')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/datums.xsd', 30, 5))
    st_6 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_6)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(ImageDatumType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'scope')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/datums.xsd', 31, 5))
    st_7 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_7)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(ImageDatumType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'anchorDefinition')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/datums.xsd', 32, 5))
    st_8 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_8)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(ImageDatumType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'realizationEpoch')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/datums.xsd', 33, 5))
    st_9 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_9)
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(ImageDatumType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'pixelInCell')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/datums.xsd', 201, 5))
    st_10 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_10)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_1, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_1, False) ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_2, True) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_2, False) ]))
    st_2._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
         ]))
    transitions.append(fac.Transition(st_5, [
         ]))
    transitions.append(fac.Transition(st_6, [
         ]))
    transitions.append(fac.Transition(st_7, [
         ]))
    st_3._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_3, True) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_3, False) ]))
    st_4._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_4, True) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_4, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_4, False) ]))
    st_5._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_5, True) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_5, False) ]))
    st_6._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_7, [
         ]))
    transitions.append(fac.Transition(st_8, [
         ]))
    transitions.append(fac.Transition(st_9, [
         ]))
    transitions.append(fac.Transition(st_10, [
         ]))
    st_7._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_8, [
        fac.UpdateInstruction(cc_6, True) ]))
    transitions.append(fac.Transition(st_9, [
        fac.UpdateInstruction(cc_6, False) ]))
    transitions.append(fac.Transition(st_10, [
        fac.UpdateInstruction(cc_6, False) ]))
    st_8._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_9, [
        fac.UpdateInstruction(cc_7, True) ]))
    transitions.append(fac.Transition(st_10, [
        fac.UpdateInstruction(cc_7, False) ]))
    st_9._set_transitionSet(transitions)
    transitions = []
    st_10._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
ImageDatumType._Automaton = _BuildAutomaton_563()




def _BuildAutomaton_564 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_564
    del _BuildAutomaton_564
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 35, 5))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 36, 5))
    counters.add(cc_1)
    cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 37, 5))
    counters.add(cc_2)
    cc_3 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 39, 5))
    counters.add(cc_3)
    cc_4 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 49, 5))
    counters.add(cc_4)
    cc_5 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/datums.xsd', 30, 5))
    counters.add(cc_5)
    cc_6 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/datums.xsd', 32, 5))
    counters.add(cc_6)
    cc_7 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/datums.xsd', 33, 5))
    counters.add(cc_7)
    states = []
    final_update = None
    symbol = pyxb.binding.content.ElementUse(VerticalDatumType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'metaDataProperty')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 35, 5))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(VerticalDatumType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'description')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 36, 5))
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(VerticalDatumType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'descriptionReference')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 37, 5))
    st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(VerticalDatumType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'identifier')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 38, 5))
    st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_3)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(VerticalDatumType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'name')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 39, 5))
    st_4 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_4)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(VerticalDatumType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'remarks')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 49, 5))
    st_5 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_5)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(VerticalDatumType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'domainOfValidity')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/datums.xsd', 30, 5))
    st_6 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_6)
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(VerticalDatumType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'scope')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/datums.xsd', 31, 5))
    st_7 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_7)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_6, False))
    symbol = pyxb.binding.content.ElementUse(VerticalDatumType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'anchorDefinition')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/datums.xsd', 32, 5))
    st_8 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_8)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_7, False))
    symbol = pyxb.binding.content.ElementUse(VerticalDatumType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'realizationEpoch')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/datums.xsd', 33, 5))
    st_9 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_9)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_1, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_1, False) ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_2, True) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_2, False) ]))
    st_2._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
         ]))
    transitions.append(fac.Transition(st_5, [
         ]))
    transitions.append(fac.Transition(st_6, [
         ]))
    transitions.append(fac.Transition(st_7, [
         ]))
    st_3._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_3, True) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_3, False) ]))
    st_4._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_4, True) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_4, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_4, False) ]))
    st_5._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_5, True) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_5, False) ]))
    st_6._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_7, [
         ]))
    transitions.append(fac.Transition(st_8, [
         ]))
    transitions.append(fac.Transition(st_9, [
         ]))
    st_7._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_8, [
        fac.UpdateInstruction(cc_6, True) ]))
    transitions.append(fac.Transition(st_9, [
        fac.UpdateInstruction(cc_6, False) ]))
    st_8._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_9, [
        fac.UpdateInstruction(cc_7, True) ]))
    st_9._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
VerticalDatumType._Automaton = _BuildAutomaton_564()




def _BuildAutomaton_565 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_565
    del _BuildAutomaton_565
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/datums.xsd', 260, 5))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/datums.xsd', 261, 5))
    counters.add(cc_1)
    cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/datums.xsd', 262, 5))
    counters.add(cc_2)
    cc_3 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/datums.xsd', 264, 5))
    counters.add(cc_3)
    cc_4 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/datums.xsd', 265, 5))
    counters.add(cc_4)
    cc_5 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/datums.xsd', 266, 5))
    counters.add(cc_5)
    states = []
    final_update = None
    symbol = pyxb.binding.content.ElementUse(TemporalDatumBaseType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'metaDataProperty')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/datums.xsd', 260, 5))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(TemporalDatumBaseType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'description')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/datums.xsd', 261, 5))
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(TemporalDatumBaseType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'descriptionReference')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/datums.xsd', 262, 5))
    st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(TemporalDatumBaseType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'identifier')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/datums.xsd', 263, 5))
    st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_3)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(TemporalDatumBaseType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'name')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/datums.xsd', 264, 5))
    st_4 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_4)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(TemporalDatumBaseType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'remarks')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/datums.xsd', 265, 5))
    st_5 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_5)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(TemporalDatumBaseType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'domainOfValidity')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/datums.xsd', 266, 5))
    st_6 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_6)
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(TemporalDatumBaseType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'scope')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/datums.xsd', 267, 5))
    st_7 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_7)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_1, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_1, False) ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_2, True) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_2, False) ]))
    st_2._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
         ]))
    transitions.append(fac.Transition(st_5, [
         ]))
    transitions.append(fac.Transition(st_6, [
         ]))
    transitions.append(fac.Transition(st_7, [
         ]))
    st_3._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_3, True) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_3, False) ]))
    st_4._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_4, True) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_4, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_4, False) ]))
    st_5._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_5, True) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_5, False) ]))
    st_6._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_7, [
         ]))
    st_7._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
TemporalDatumBaseType._Automaton = _BuildAutomaton_565()




def _BuildAutomaton_566 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_566
    del _BuildAutomaton_566
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 35, 5))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 36, 5))
    counters.add(cc_1)
    cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 37, 5))
    counters.add(cc_2)
    cc_3 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 39, 5))
    counters.add(cc_3)
    cc_4 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 49, 5))
    counters.add(cc_4)
    states = []
    final_update = None
    symbol = pyxb.binding.content.ElementUse(TemporalCSType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'metaDataProperty')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 35, 5))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(TemporalCSType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'description')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 36, 5))
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(TemporalCSType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'descriptionReference')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 37, 5))
    st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(TemporalCSType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'identifier')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 38, 5))
    st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_3)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(TemporalCSType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'name')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 39, 5))
    st_4 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_4)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(TemporalCSType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'remarks')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 49, 5))
    st_5 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_5)
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(TemporalCSType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'axis')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateSystems.xsd', 87, 5))
    st_6 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_6)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_1, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_1, False) ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_2, True) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_2, False) ]))
    st_2._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
         ]))
    transitions.append(fac.Transition(st_5, [
         ]))
    transitions.append(fac.Transition(st_6, [
         ]))
    st_3._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_3, True) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_3, False) ]))
    st_4._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_4, True) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_4, False) ]))
    st_5._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_6, [
         ]))
    st_6._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
TemporalCSType._Automaton = _BuildAutomaton_566()




def _BuildAutomaton_567 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_567
    del _BuildAutomaton_567
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 35, 5))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 36, 5))
    counters.add(cc_1)
    cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 37, 5))
    counters.add(cc_2)
    cc_3 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 39, 5))
    counters.add(cc_3)
    cc_4 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 49, 5))
    counters.add(cc_4)
    states = []
    final_update = None
    symbol = pyxb.binding.content.ElementUse(ObliqueCartesianCSType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'metaDataProperty')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 35, 5))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(ObliqueCartesianCSType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'description')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 36, 5))
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(ObliqueCartesianCSType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'descriptionReference')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 37, 5))
    st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(ObliqueCartesianCSType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'identifier')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 38, 5))
    st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_3)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(ObliqueCartesianCSType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'name')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 39, 5))
    st_4 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_4)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(ObliqueCartesianCSType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'remarks')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 49, 5))
    st_5 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_5)
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(ObliqueCartesianCSType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'axis')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateSystems.xsd', 87, 5))
    st_6 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_6)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_1, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_1, False) ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_2, True) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_2, False) ]))
    st_2._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
         ]))
    transitions.append(fac.Transition(st_5, [
         ]))
    transitions.append(fac.Transition(st_6, [
         ]))
    st_3._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_3, True) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_3, False) ]))
    st_4._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_4, True) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_4, False) ]))
    st_5._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_6, [
         ]))
    st_6._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
ObliqueCartesianCSType._Automaton = _BuildAutomaton_567()




GeographicCRSType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'usesEllipsoidalCS'), EllipsoidalCSPropertyType, scope=GeographicCRSType, documentation='', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 346, 1)))

GeographicCRSType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'usesGeodeticDatum'), GeodeticDatumPropertyType, scope=GeographicCRSType, documentation='', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 361, 1)))

def _BuildAutomaton_568 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_568
    del _BuildAutomaton_568
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 35, 5))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 36, 5))
    counters.add(cc_1)
    cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 37, 5))
    counters.add(cc_2)
    cc_3 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 39, 5))
    counters.add(cc_3)
    cc_4 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 49, 5))
    counters.add(cc_4)
    cc_5 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/referenceSystems.xsd', 39, 5))
    counters.add(cc_5)
    states = []
    final_update = None
    symbol = pyxb.binding.content.ElementUse(GeographicCRSType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'metaDataProperty')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 35, 5))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(GeographicCRSType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'description')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 36, 5))
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(GeographicCRSType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'descriptionReference')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 37, 5))
    st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(GeographicCRSType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'identifier')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 38, 5))
    st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_3)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(GeographicCRSType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'name')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 39, 5))
    st_4 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_4)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(GeographicCRSType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'remarks')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 49, 5))
    st_5 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_5)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(GeographicCRSType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'domainOfValidity')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/referenceSystems.xsd', 39, 5))
    st_6 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_6)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(GeographicCRSType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'scope')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/referenceSystems.xsd', 40, 5))
    st_7 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_7)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(GeographicCRSType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'usesEllipsoidalCS')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 463, 5))
    st_8 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_8)
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(GeographicCRSType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'usesGeodeticDatum')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 464, 5))
    st_9 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_9)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_1, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_1, False) ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_2, True) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_2, False) ]))
    st_2._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
         ]))
    transitions.append(fac.Transition(st_5, [
         ]))
    transitions.append(fac.Transition(st_6, [
         ]))
    transitions.append(fac.Transition(st_7, [
         ]))
    st_3._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_3, True) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_3, False) ]))
    st_4._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_4, True) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_4, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_4, False) ]))
    st_5._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_5, True) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_5, False) ]))
    st_6._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_7, [
         ]))
    transitions.append(fac.Transition(st_8, [
         ]))
    st_7._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_9, [
         ]))
    st_8._set_transitionSet(transitions)
    transitions = []
    st_9._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
GeographicCRSType._Automaton = _BuildAutomaton_568()




GeocentricCRSType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'usesCartesianCS'), CartesianCSPropertyType, scope=GeocentricCRSType, documentation='', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 351, 1)))

GeocentricCRSType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'usesSphericalCS'), SphericalCSPropertyType, scope=GeocentricCRSType, documentation='', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 356, 1)))

GeocentricCRSType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'usesGeodeticDatum'), GeodeticDatumPropertyType, scope=GeocentricCRSType, documentation='', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 361, 1)))

def _BuildAutomaton_569 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_569
    del _BuildAutomaton_569
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 35, 5))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 36, 5))
    counters.add(cc_1)
    cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 37, 5))
    counters.add(cc_2)
    cc_3 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 39, 5))
    counters.add(cc_3)
    cc_4 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 49, 5))
    counters.add(cc_4)
    cc_5 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/referenceSystems.xsd', 39, 5))
    counters.add(cc_5)
    states = []
    final_update = None
    symbol = pyxb.binding.content.ElementUse(GeocentricCRSType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'metaDataProperty')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 35, 5))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(GeocentricCRSType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'description')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 36, 5))
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(GeocentricCRSType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'descriptionReference')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 37, 5))
    st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(GeocentricCRSType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'identifier')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 38, 5))
    st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_3)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(GeocentricCRSType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'name')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 39, 5))
    st_4 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_4)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(GeocentricCRSType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'remarks')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 49, 5))
    st_5 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_5)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(GeocentricCRSType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'domainOfValidity')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/referenceSystems.xsd', 39, 5))
    st_6 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_6)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(GeocentricCRSType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'scope')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/referenceSystems.xsd', 40, 5))
    st_7 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_7)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(GeocentricCRSType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'usesCartesianCS')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 496, 6))
    st_8 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_8)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(GeocentricCRSType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'usesSphericalCS')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 497, 6))
    st_9 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_9)
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(GeocentricCRSType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'usesGeodeticDatum')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 499, 5))
    st_10 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_10)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_1, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_1, False) ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_2, True) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_2, False) ]))
    st_2._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
         ]))
    transitions.append(fac.Transition(st_5, [
         ]))
    transitions.append(fac.Transition(st_6, [
         ]))
    transitions.append(fac.Transition(st_7, [
         ]))
    st_3._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_3, True) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_3, False) ]))
    st_4._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_4, True) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_4, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_4, False) ]))
    st_5._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_5, True) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_5, False) ]))
    st_6._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_7, [
         ]))
    transitions.append(fac.Transition(st_8, [
         ]))
    transitions.append(fac.Transition(st_9, [
         ]))
    st_7._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_10, [
         ]))
    st_8._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_10, [
         ]))
    st_9._set_transitionSet(transitions)
    transitions = []
    st_10._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
GeocentricCRSType._Automaton = _BuildAutomaton_569()




LinearRingType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'coordinates'), CoordinatesType, scope=LinearRingType, documentation='', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 751, 1)))

LinearRingType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'pointRep'), PointPropertyType, scope=LinearRingType, documentation='', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 756, 1)))

LinearRingType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'pos'), DirectPositionType, scope=LinearRingType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic0d1d.xsd', 87, 1)))

LinearRingType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'posList'), DirectPositionListType, scope=LinearRingType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic0d1d.xsd', 102, 1)))

LinearRingType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'pointProperty'), PointPropertyType, scope=LinearRingType, documentation='This property element either references a point via the XLink-attributes or contains the point element. pointProperty is the predefined property which may be used by GML Application Schemas whenever a GML feature has a property with a value that is substitutable for Point.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic0d1d.xsd', 204, 1)))

def _BuildAutomaton_570 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_570
    del _BuildAutomaton_570
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 39, 3))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 40, 3))
    counters.add(cc_1)
    cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 41, 3))
    counters.add(cc_2)
    cc_3 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 42, 3))
    counters.add(cc_3)
    cc_4 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 43, 3))
    counters.add(cc_4)
    cc_5 = fac.CounterCondition(min=4, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic2d.xsd', 103, 6))
    counters.add(cc_5)
    states = []
    final_update = None
    symbol = pyxb.binding.content.ElementUse(LinearRingType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'metaDataProperty')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 39, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(LinearRingType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'description')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 40, 3))
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(LinearRingType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'descriptionReference')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 41, 3))
    st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(LinearRingType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'identifier')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 42, 3))
    st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_3)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(LinearRingType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'name')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 43, 3))
    st_4 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_4)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_5, False))
    symbol = pyxb.binding.content.ElementUse(LinearRingType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'pos')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic2d.xsd', 104, 7))
    st_5 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_5)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_5, False))
    symbol = pyxb.binding.content.ElementUse(LinearRingType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'pointProperty')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic2d.xsd', 105, 7))
    st_6 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_6)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_5, False))
    symbol = pyxb.binding.content.ElementUse(LinearRingType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'pointRep')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic2d.xsd', 106, 7))
    st_7 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_7)
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(LinearRingType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'posList')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic2d.xsd', 108, 6))
    st_8 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_8)
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(LinearRingType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'coordinates')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryBasic2d.xsd', 109, 6))
    st_9 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_9)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_8, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_9, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_1, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_8, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_9, [
        fac.UpdateInstruction(cc_1, False) ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_2, True) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_8, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_9, [
        fac.UpdateInstruction(cc_2, False) ]))
    st_2._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_3, True) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_8, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_9, [
        fac.UpdateInstruction(cc_3, False) ]))
    st_3._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_4, True) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_4, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_4, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_4, False) ]))
    transitions.append(fac.Transition(st_8, [
        fac.UpdateInstruction(cc_4, False) ]))
    transitions.append(fac.Transition(st_9, [
        fac.UpdateInstruction(cc_4, False) ]))
    st_4._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_5, True) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_5, True) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_5, True) ]))
    st_5._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_5, True) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_5, True) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_5, True) ]))
    st_6._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_5, True) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_5, True) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_5, True) ]))
    st_7._set_transitionSet(transitions)
    transitions = []
    st_8._set_transitionSet(transitions)
    transitions = []
    st_9._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
LinearRingType._Automaton = _BuildAutomaton_570()




RingType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'curveMember'), CurvePropertyType, scope=RingType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 639, 1)))

def _BuildAutomaton_571 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_571
    del _BuildAutomaton_571
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 39, 3))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 40, 3))
    counters.add(cc_1)
    cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 41, 3))
    counters.add(cc_2)
    cc_3 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 42, 3))
    counters.add(cc_3)
    cc_4 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 43, 3))
    counters.add(cc_4)
    states = []
    final_update = None
    symbol = pyxb.binding.content.ElementUse(RingType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'metaDataProperty')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 39, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(RingType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'description')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 40, 3))
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(RingType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'descriptionReference')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 41, 3))
    st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(RingType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'identifier')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 42, 3))
    st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_3)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(RingType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'name')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 43, 3))
    st_4 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_4)
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(RingType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'curveMember')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 626, 5))
    st_5 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_5)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_1, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_1, False) ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_2, True) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_2, False) ]))
    st_2._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_3, True) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_3, False) ]))
    st_3._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_4, True) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_4, False) ]))
    st_4._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_5, [
         ]))
    st_5._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
RingType._Automaton = _BuildAutomaton_571()




TinType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'stopLines'), LineStringSegmentArrayPropertyType, scope=TinType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 739, 5)))

TinType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'breakLines'), LineStringSegmentArrayPropertyType, scope=TinType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 740, 5)))

TinType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'maxLength'), LengthType, scope=TinType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 741, 5)))

TinType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'controlPoint'), CTD_ANON_5, scope=TinType, location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 742, 5)))

def _BuildAutomaton_572 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_572
    del _BuildAutomaton_572
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 39, 3))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 40, 3))
    counters.add(cc_1)
    cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 41, 3))
    counters.add(cc_2)
    cc_3 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 42, 3))
    counters.add(cc_3)
    cc_4 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 43, 3))
    counters.add(cc_4)
    cc_5 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 739, 5))
    counters.add(cc_5)
    cc_6 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 740, 5))
    counters.add(cc_6)
    states = []
    final_update = None
    symbol = pyxb.binding.content.ElementUse(TinType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'metaDataProperty')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 39, 3))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(TinType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'description')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 40, 3))
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(TinType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'descriptionReference')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 41, 3))
    st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(TinType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'identifier')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 42, 3))
    st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_3)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(TinType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'name')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/gmlBase.xsd', 43, 3))
    st_4 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_4)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(TinType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'patches')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 502, 5))
    st_5 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_5)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(TinType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'stopLines')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 739, 5))
    st_6 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_6)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(TinType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'breakLines')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 740, 5))
    st_7 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_7)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(TinType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'maxLength')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 741, 5))
    st_8 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_8)
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(TinType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'controlPoint')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/geometryPrimitives.xsd', 742, 5))
    st_9 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_9)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_1, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_1, False) ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_2, True) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_2, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_2, False) ]))
    st_2._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_3, True) ]))
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_3, False) ]))
    st_3._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_4, True) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_4, False) ]))
    st_4._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_6, [
         ]))
    transitions.append(fac.Transition(st_7, [
         ]))
    transitions.append(fac.Transition(st_8, [
         ]))
    st_5._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_5, True) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_5, False) ]))
    transitions.append(fac.Transition(st_8, [
        fac.UpdateInstruction(cc_5, False) ]))
    st_6._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_6, True) ]))
    transitions.append(fac.Transition(st_8, [
        fac.UpdateInstruction(cc_6, False) ]))
    st_7._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_9, [
         ]))
    st_8._set_transitionSet(transitions)
    transitions = []
    st_9._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
TinType._Automaton = _BuildAutomaton_572()




ConversionType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'method'), OperationMethodPropertyType, scope=ConversionType, documentation='gml:method is an association role to the operation method used by a coordinate operation.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 238, 1)))

ConversionType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'parameterValue'), AbstractGeneralParameterValuePropertyType, scope=ConversionType, documentation='gml:parameterValue is a composition association to a parameter value or group of parameter values used by a coordinate operation.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 243, 1)))

def _BuildAutomaton_573 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_573
    del _BuildAutomaton_573
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 102, 5))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 103, 5))
    counters.add(cc_1)
    cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 104, 5))
    counters.add(cc_2)
    cc_3 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 106, 5))
    counters.add(cc_3)
    cc_4 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 107, 5))
    counters.add(cc_4)
    cc_5 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 108, 5))
    counters.add(cc_5)
    cc_6 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 110, 5))
    counters.add(cc_6)
    cc_7 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 233, 5))
    counters.add(cc_7)
    states = []
    final_update = None
    symbol = pyxb.binding.content.ElementUse(ConversionType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'metaDataProperty')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 102, 5))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(ConversionType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'description')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 103, 5))
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(ConversionType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'descriptionReference')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 104, 5))
    st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(ConversionType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'identifier')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 105, 5))
    st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_3)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(ConversionType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'name')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 106, 5))
    st_4 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_4)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(ConversionType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'remarks')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 107, 5))
    st_5 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_5)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(ConversionType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'domainOfValidity')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 108, 5))
    st_6 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_6)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(ConversionType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'scope')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 109, 5))
    st_7 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_7)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(ConversionType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'coordinateOperationAccuracy')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 110, 5))
    st_8 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_8)
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(ConversionType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'method')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 232, 5))
    st_9 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_9)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_7, False))
    symbol = pyxb.binding.content.ElementUse(ConversionType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'parameterValue')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 233, 5))
    st_10 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_10)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_1, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_1, False) ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_2, True) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_2, False) ]))
    st_2._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
         ]))
    transitions.append(fac.Transition(st_5, [
         ]))
    transitions.append(fac.Transition(st_6, [
         ]))
    transitions.append(fac.Transition(st_7, [
         ]))
    st_3._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_3, True) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_3, False) ]))
    st_4._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_4, True) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_4, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_4, False) ]))
    st_5._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_5, True) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_5, False) ]))
    st_6._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_7, [
         ]))
    transitions.append(fac.Transition(st_8, [
         ]))
    transitions.append(fac.Transition(st_9, [
         ]))
    st_7._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_8, [
        fac.UpdateInstruction(cc_6, True) ]))
    transitions.append(fac.Transition(st_9, [
        fac.UpdateInstruction(cc_6, False) ]))
    st_8._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_10, [
         ]))
    st_9._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_10, [
        fac.UpdateInstruction(cc_7, True) ]))
    st_10._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
ConversionType._Automaton = _BuildAutomaton_573()




TransformationType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'method'), OperationMethodPropertyType, scope=TransformationType, documentation='gml:method is an association role to the operation method used by a coordinate operation.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 238, 1)))

TransformationType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'parameterValue'), AbstractGeneralParameterValuePropertyType, scope=TransformationType, documentation='gml:parameterValue is a composition association to a parameter value or group of parameter values used by a coordinate operation.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 243, 1)))

def _BuildAutomaton_574 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_574
    del _BuildAutomaton_574
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 135, 5))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 136, 5))
    counters.add(cc_1)
    cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 137, 5))
    counters.add(cc_2)
    cc_3 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 139, 5))
    counters.add(cc_3)
    cc_4 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 140, 5))
    counters.add(cc_4)
    cc_5 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 141, 5))
    counters.add(cc_5)
    cc_6 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 144, 5))
    counters.add(cc_6)
    cc_7 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 269, 5))
    counters.add(cc_7)
    states = []
    final_update = None
    symbol = pyxb.binding.content.ElementUse(TransformationType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'metaDataProperty')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 135, 5))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(TransformationType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'description')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 136, 5))
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(TransformationType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'descriptionReference')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 137, 5))
    st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(TransformationType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'identifier')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 138, 5))
    st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_3)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(TransformationType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'name')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 139, 5))
    st_4 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_4)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(TransformationType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'remarks')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 140, 5))
    st_5 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_5)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(TransformationType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'domainOfValidity')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 141, 5))
    st_6 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_6)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(TransformationType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'scope')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 142, 5))
    st_7 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_7)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(TransformationType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'operationVersion')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 143, 5))
    st_8 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_8)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(TransformationType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'coordinateOperationAccuracy')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 144, 5))
    st_9 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_9)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(TransformationType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'sourceCRS')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 145, 5))
    st_10 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_10)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(TransformationType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'targetCRS')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 146, 5))
    st_11 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_11)
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(TransformationType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'method')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 268, 5))
    st_12 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_12)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_7, False))
    symbol = pyxb.binding.content.ElementUse(TransformationType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'parameterValue')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateOperations.xsd', 269, 5))
    st_13 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_13)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_1, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_1, False) ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_2, True) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_2, False) ]))
    st_2._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
         ]))
    transitions.append(fac.Transition(st_5, [
         ]))
    transitions.append(fac.Transition(st_6, [
         ]))
    transitions.append(fac.Transition(st_7, [
         ]))
    st_3._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_3, True) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_3, False) ]))
    st_4._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_4, True) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_4, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_4, False) ]))
    st_5._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_5, True) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_5, False) ]))
    st_6._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_7, [
         ]))
    transitions.append(fac.Transition(st_8, [
         ]))
    st_7._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_9, [
         ]))
    transitions.append(fac.Transition(st_10, [
         ]))
    st_8._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_9, [
        fac.UpdateInstruction(cc_6, True) ]))
    transitions.append(fac.Transition(st_10, [
        fac.UpdateInstruction(cc_6, False) ]))
    st_9._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_11, [
         ]))
    st_10._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_12, [
         ]))
    st_11._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_13, [
         ]))
    st_12._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_13, [
        fac.UpdateInstruction(cc_7, True) ]))
    st_13._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
TransformationType._Automaton = _BuildAutomaton_574()




ProjectedCRSType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'cartesianCS'), CartesianCSPropertyType, scope=ProjectedCRSType, documentation='gml:cartesianCS is an association role to the Cartesian coordinate system used by this CRS.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateReferenceSystems.xsd', 103, 1)))

ProjectedCRSType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'baseGeodeticCRS'), GeodeticCRSPropertyType, scope=ProjectedCRSType, documentation='gml:baseGeodeticCRS is an association role to the geodetic coordinate reference system used by this projected CRS.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateReferenceSystems.xsd', 180, 1)))

ProjectedCRSType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'baseGeographicCRS'), GeographicCRSPropertyType, scope=ProjectedCRSType, documentation='', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/deprecatedTypes.xsd', 381, 1)))

def _BuildAutomaton_575 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_575
    del _BuildAutomaton_575
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 35, 5))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 36, 5))
    counters.add(cc_1)
    cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 37, 5))
    counters.add(cc_2)
    cc_3 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 39, 5))
    counters.add(cc_3)
    cc_4 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 49, 5))
    counters.add(cc_4)
    cc_5 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/referenceSystems.xsd', 39, 5))
    counters.add(cc_5)
    states = []
    final_update = None
    symbol = pyxb.binding.content.ElementUse(ProjectedCRSType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'metaDataProperty')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 35, 5))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(ProjectedCRSType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'description')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 36, 5))
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(ProjectedCRSType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'descriptionReference')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 37, 5))
    st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(ProjectedCRSType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'identifier')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 38, 5))
    st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_3)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(ProjectedCRSType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'name')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 39, 5))
    st_4 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_4)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(ProjectedCRSType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'remarks')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 49, 5))
    st_5 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_5)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(ProjectedCRSType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'domainOfValidity')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/referenceSystems.xsd', 39, 5))
    st_6 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_6)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(ProjectedCRSType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'scope')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/referenceSystems.xsd', 40, 5))
    st_7 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_7)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(ProjectedCRSType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'conversion')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateReferenceSystems.xsd', 41, 5))
    st_8 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_8)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(ProjectedCRSType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'baseGeodeticCRS')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateReferenceSystems.xsd', 172, 6))
    st_9 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_9)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(ProjectedCRSType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'baseGeographicCRS')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateReferenceSystems.xsd', 173, 6))
    st_10 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_10)
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(ProjectedCRSType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'cartesianCS')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateReferenceSystems.xsd', 175, 5))
    st_11 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_11)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_1, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_1, False) ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_2, True) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_2, False) ]))
    st_2._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
         ]))
    transitions.append(fac.Transition(st_5, [
         ]))
    transitions.append(fac.Transition(st_6, [
         ]))
    transitions.append(fac.Transition(st_7, [
         ]))
    st_3._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_3, True) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_3, False) ]))
    st_4._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_4, True) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_4, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_4, False) ]))
    st_5._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_5, True) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_5, False) ]))
    st_6._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_7, [
         ]))
    transitions.append(fac.Transition(st_8, [
         ]))
    st_7._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_9, [
         ]))
    transitions.append(fac.Transition(st_10, [
         ]))
    st_8._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_11, [
         ]))
    st_9._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_11, [
         ]))
    st_10._set_transitionSet(transitions)
    transitions = []
    st_11._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
ProjectedCRSType._Automaton = _BuildAutomaton_575()




DerivedCRSType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'baseCRS'), SingleCRSPropertyType, scope=DerivedCRSType, documentation='gml:baseCRS is an association role to the coordinate reference system used by this derived CRS.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateReferenceSystems.xsd', 210, 1)))

DerivedCRSType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'derivedCRSType'), CodeWithAuthorityType, scope=DerivedCRSType, documentation='The gml:derivedCRSType property describes the type of a derived coordinate reference system. The required codeSpace attribute shall reference a source of information specifying the values and meanings of all the allowed string values for this property.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateReferenceSystems.xsd', 215, 1)))

DerivedCRSType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'coordinateSystem'), CoordinateSystemPropertyType, scope=DerivedCRSType, documentation='An association role to the coordinate system used by this CRS.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateReferenceSystems.xsd', 220, 1)))

def _BuildAutomaton_576 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_576
    del _BuildAutomaton_576
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 35, 5))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 36, 5))
    counters.add(cc_1)
    cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 37, 5))
    counters.add(cc_2)
    cc_3 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 39, 5))
    counters.add(cc_3)
    cc_4 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 49, 5))
    counters.add(cc_4)
    cc_5 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/referenceSystems.xsd', 39, 5))
    counters.add(cc_5)
    states = []
    final_update = None
    symbol = pyxb.binding.content.ElementUse(DerivedCRSType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'metaDataProperty')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 35, 5))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(DerivedCRSType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'description')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 36, 5))
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(DerivedCRSType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'descriptionReference')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 37, 5))
    st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(DerivedCRSType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'identifier')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 38, 5))
    st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_3)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(DerivedCRSType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'name')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 39, 5))
    st_4 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_4)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(DerivedCRSType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'remarks')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/dictionary.xsd', 49, 5))
    st_5 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_5)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(DerivedCRSType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'domainOfValidity')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/referenceSystems.xsd', 39, 5))
    st_6 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_6)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(DerivedCRSType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'scope')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/referenceSystems.xsd', 40, 5))
    st_7 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_7)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(DerivedCRSType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'conversion')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateReferenceSystems.xsd', 41, 5))
    st_8 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_8)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(DerivedCRSType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'baseCRS')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateReferenceSystems.xsd', 203, 5))
    st_9 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_9)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(DerivedCRSType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'derivedCRSType')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateReferenceSystems.xsd', 204, 5))
    st_10 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_10)
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(DerivedCRSType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'coordinateSystem')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/coordinateReferenceSystems.xsd', 205, 5))
    st_11 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_11)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_1, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_1, False) ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_2, True) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_2, False) ]))
    st_2._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
         ]))
    transitions.append(fac.Transition(st_5, [
         ]))
    transitions.append(fac.Transition(st_6, [
         ]))
    transitions.append(fac.Transition(st_7, [
         ]))
    st_3._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_3, True) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_3, False) ]))
    st_4._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_4, True) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_4, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_4, False) ]))
    st_5._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_5, True) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_5, False) ]))
    st_6._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_7, [
         ]))
    transitions.append(fac.Transition(st_8, [
         ]))
    st_7._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_9, [
         ]))
    st_8._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_10, [
         ]))
    st_9._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_11, [
         ]))
    st_10._set_transitionSet(transitions)
    transitions = []
    st_11._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
DerivedCRSType._Automaton = _BuildAutomaton_576()




TemporalDatumType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(_Namespace_gml, 'origin'), pyxb.binding.datatypes.dateTime, scope=TemporalDatumType, documentation='gml:origin is the date and time origin of this temporal datum.', location=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/datums.xsd', 273, 1)))

def _BuildAutomaton_577 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_577
    del _BuildAutomaton_577
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/datums.xsd', 260, 5))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/datums.xsd', 261, 5))
    counters.add(cc_1)
    cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/datums.xsd', 262, 5))
    counters.add(cc_2)
    cc_3 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/datums.xsd', 264, 5))
    counters.add(cc_3)
    cc_4 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/datums.xsd', 265, 5))
    counters.add(cc_4)
    cc_5 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/datums.xsd', 266, 5))
    counters.add(cc_5)
    states = []
    final_update = None
    symbol = pyxb.binding.content.ElementUse(TemporalDatumType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'metaDataProperty')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/datums.xsd', 260, 5))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(TemporalDatumType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'description')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/datums.xsd', 261, 5))
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_1)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(TemporalDatumType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'descriptionReference')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/datums.xsd', 262, 5))
    st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_2)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(TemporalDatumType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'identifier')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/datums.xsd', 263, 5))
    st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_3)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(TemporalDatumType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'name')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/datums.xsd', 264, 5))
    st_4 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_4)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(TemporalDatumType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'remarks')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/datums.xsd', 265, 5))
    st_5 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_5)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(TemporalDatumType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'domainOfValidity')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/datums.xsd', 266, 5))
    st_6 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_6)
    final_update = None
    symbol = pyxb.binding.content.ElementUse(TemporalDatumType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'scope')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/datums.xsd', 267, 5))
    st_7 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_7)
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(TemporalDatumType._UseForTag(pyxb.namespace.ExpandedName(_Namespace_gml, 'origin')), pyxb.utils.utility.Location('http://schemas.opengis.net/gml/3.2.1/datums.xsd', 248, 5))
    st_8 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
    states.append(st_8)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_1, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_1, False) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_1, False) ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_2, True) ]))
    transitions.append(fac.Transition(st_3, [
        fac.UpdateInstruction(cc_2, False) ]))
    st_2._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
         ]))
    transitions.append(fac.Transition(st_5, [
         ]))
    transitions.append(fac.Transition(st_6, [
         ]))
    transitions.append(fac.Transition(st_7, [
         ]))
    st_3._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_4, [
        fac.UpdateInstruction(cc_3, True) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_3, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_3, False) ]))
    st_4._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_4, True) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_4, False) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_4, False) ]))
    st_5._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_5, True) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_5, False) ]))
    st_6._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_7, [
         ]))
    transitions.append(fac.Transition(st_8, [
         ]))
    st_7._set_transitionSet(transitions)
    transitions = []
    st_8._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
TemporalDatumType._Automaton = _BuildAutomaton_577()


AbstractValue._setSubstitutionGroup(AbstractObject)

AbstractScalarValue._setSubstitutionGroup(AbstractValue)

AbstractScalarValueList._setSubstitutionGroup(AbstractValue)

LocalName._setSubstitutionGroup(AbstractGenericName)

ScopedName._setSubstitutionGroup(AbstractGenericName)

CI_RoleCode._setSubstitutionGroup(CharacterString)

CI_PresentationFormCode._setSubstitutionGroup(CharacterString)

CI_OnLineFunctionCode._setSubstitutionGroup(CharacterString)

CI_DateTypeCode._setSubstitutionGroup(CharacterString)

MD_ClassificationCode._setSubstitutionGroup(CharacterString)

MD_RestrictionCode._setSubstitutionGroup(CharacterString)

MD_CoverageContentTypeCode._setSubstitutionGroup(CharacterString)

MD_ImagingConditionCode._setSubstitutionGroup(CharacterString)

DQ_EvaluationMethodTypeCode._setSubstitutionGroup(CharacterString)

MD_DistributionUnits._setSubstitutionGroup(CharacterString)

MD_MediumFormatCode._setSubstitutionGroup(CharacterString)

MD_MediumNameCode._setSubstitutionGroup(CharacterString)

LocalisedCharacterString._setSubstitutionGroup(CharacterString)

LanguageCode._setSubstitutionGroup(CharacterString)

Country._setSubstitutionGroup(CharacterString)

MD_TopicCategoryCode._setSubstitutionGroup(CharacterString)

MD_CharacterSetCode._setSubstitutionGroup(CharacterString)

MD_SpatialRepresentationTypeCode._setSubstitutionGroup(CharacterString)

MD_ProgressCode._setSubstitutionGroup(CharacterString)

MD_KeywordTypeCode._setSubstitutionGroup(CharacterString)

DS_AssociationTypeCode._setSubstitutionGroup(CharacterString)

DS_InitiativeTypeCode._setSubstitutionGroup(CharacterString)

MD_MaintenanceFrequencyCode._setSubstitutionGroup(CharacterString)

MD_ScopeCode._setSubstitutionGroup(CharacterString)

MD_ObligationCode._setSubstitutionGroup(CharacterString)

MD_DatatypeCode._setSubstitutionGroup(CharacterString)

MD_PixelOrientationCode._setSubstitutionGroup(CharacterString)

MD_TopologyLevelCode._setSubstitutionGroup(CharacterString)

MD_GeometricObjectTypeCode._setSubstitutionGroup(CharacterString)

MD_CellGeometryCode._setSubstitutionGroup(CharacterString)

MD_DimensionNameTypeCode._setSubstitutionGroup(CharacterString)

AbstractGeneralParameterValue._setSubstitutionGroup(AbstractObject)

DataBlock._setSubstitutionGroup(AbstractObject)

File._setSubstitutionGroup(AbstractObject)

coverageFunction._setSubstitutionGroup(AbstractObject)

CoverageMappingRule._setSubstitutionGroup(AbstractObject)

GridFunction._setSubstitutionGroup(AbstractObject)

anchorPoint._setSubstitutionGroup(anchorDefinition)

usesValue._setSubstitutionGroup(parameterValue)

includesValue._setSubstitutionGroup(parameterValue)

methodFormula._setSubstitutionGroup(formula)

AbstractMetaData._setSubstitutionGroup(AbstractObject)

track._setSubstitutionGroup(history)

polygonPatches._setSubstitutionGroup(patches)

trianglePatches._setSubstitutionGroup(patches)

AbstractCurveSegment._setSubstitutionGroup(AbstractObject)

AffinePlacement._setSubstitutionGroup(AbstractObject)

AbstractGML._setSubstitutionGroup(AbstractObject)

ParameterValue._setSubstitutionGroup(AbstractGeneralParameterValue)

ParameterValueGroup._setSubstitutionGroup(AbstractGeneralParameterValue)

Bag._setSubstitutionGroup(AbstractGML)

Array._setSubstitutionGroup(AbstractGML)

GenericMetaData._setSubstitutionGroup(AbstractMetaData)

AbstractTimeSlice._setSubstitutionGroup(AbstractGML)

AbstractFeature._setSubstitutionGroup(AbstractGML)

AbstractGeometry._setSubstitutionGroup(AbstractGML)

Envelope._setSubstitutionGroup(AbstractObject)

LineStringSegment._setSubstitutionGroup(AbstractCurveSegment)

ArcString._setSubstitutionGroup(AbstractCurveSegment)

ArcStringByBulge._setSubstitutionGroup(AbstractCurveSegment)

ArcByCenterPoint._setSubstitutionGroup(AbstractCurveSegment)

CubicSpline._setSubstitutionGroup(AbstractCurveSegment)

BSpline._setSubstitutionGroup(AbstractCurveSegment)

OffsetCurve._setSubstitutionGroup(AbstractCurveSegment)

Clothoid._setSubstitutionGroup(AbstractCurveSegment)

GeodesicString._setSubstitutionGroup(AbstractCurveSegment)

PolygonPatch._setSubstitutionGroup(AbstractSurfacePatch)

Triangle._setSubstitutionGroup(AbstractSurfacePatch)

Rectangle._setSubstitutionGroup(AbstractSurfacePatch)

AbstractParametricCurveSurface._setSubstitutionGroup(AbstractSurfacePatch)

AbstractImplicitGeometry._setSubstitutionGroup(AbstractGeometry)

AbstractTimeObject._setSubstitutionGroup(AbstractGML)

AbstractTopology._setSubstitutionGroup(AbstractGML)

CompositeValue._setSubstitutionGroup(AbstractValue)

MD_LegalConstraints._setSubstitutionGroup(MD_Constraints)

MD_SecurityConstraints._setSubstitutionGroup(MD_Constraints)

MD_FeatureCatalogueDescription._setSubstitutionGroup(AbstractMD_ContentInformation)

MD_CoverageDescription._setSubstitutionGroup(AbstractMD_ContentInformation)

MD_Band._setSubstitutionGroup(MD_RangeDimension)

DQ_ConformanceResult._setSubstitutionGroup(AbstractDQ_Result)

DQ_QuantitativeResult._setSubstitutionGroup(AbstractDQ_Result)

AbstractDQ_TemporalAccuracy._setSubstitutionGroup(AbstractDQ_Element)

AbstractDQ_ThematicAccuracy._setSubstitutionGroup(AbstractDQ_Element)

AbstractDQ_PositionalAccuracy._setSubstitutionGroup(AbstractDQ_Element)

AbstractDQ_LogicalConsistency._setSubstitutionGroup(AbstractDQ_Element)

AbstractDQ_Completeness._setSubstitutionGroup(AbstractDQ_Element)

EX_BoundingPolygon._setSubstitutionGroup(AbstractEX_GeographicExtent)

EX_GeographicBoundingBox._setSubstitutionGroup(AbstractEX_GeographicExtent)

EX_SpatialTemporalExtent._setSubstitutionGroup(EX_TemporalExtent)

EX_GeographicDescription._setSubstitutionGroup(AbstractEX_GeographicExtent)

MD_DataIdentification._setSubstitutionGroup(AbstractMD_Identification)

MD_ServiceIdentification._setSubstitutionGroup(AbstractMD_Identification)

DS_OtherAggregate._setSubstitutionGroup(AbstractDS_Aggregate)

DS_Series._setSubstitutionGroup(AbstractDS_Aggregate)

DS_Initiative._setSubstitutionGroup(AbstractDS_Aggregate)

RS_Identifier._setSubstitutionGroup(MD_Identifier)

MD_GridSpatialRepresentation._setSubstitutionGroup(AbstractMD_SpatialRepresentation)

MD_VectorSpatialRepresentation._setSubstitutionGroup(AbstractMD_SpatialRepresentation)

AbstractCoverage._setSubstitutionGroup(AbstractFeature)

usesPrimeMeridian._setSubstitutionGroup(primeMeridian)

usesEllipsoid._setSubstitutionGroup(ellipsoid)

usesSingleOperation._setSubstitutionGroup(coordOperation)

usesOperation._setSubstitutionGroup(coordOperation)

usesMethod._setSubstitutionGroup(method)

valueOfParameter._setSubstitutionGroup(operationParameter)

valuesOfGroup._setSubstitutionGroup(group)

usesParameter._setSubstitutionGroup(generalOperationParameter)

includesParameter._setSubstitutionGroup(parameter)

usesAxis._setSubstitutionGroup(axis)

definedByConversion._setSubstitutionGroup(conversion)

includesSingleCRS._setSubstitutionGroup(componentReferenceSystem)

usesEllipsoidalCS._setSubstitutionGroup(ellipsoidalCS)

usesCartesianCS._setSubstitutionGroup(cartesianCS)

usesSphericalCS._setSubstitutionGroup(sphericalCS)

usesGeodeticDatum._setSubstitutionGroup(geodeticDatum)

usesVerticalCS._setSubstitutionGroup(verticalCS)

usesVerticalDatum._setSubstitutionGroup(verticalDatum)

usesCS._setSubstitutionGroup(coordinateSystem)

usesEngineeringDatum._setSubstitutionGroup(engineeringDatum)

usesAffineCS._setSubstitutionGroup(affineCS)

usesImageDatum._setSubstitutionGroup(imageDatum)

usesTimeCS._setSubstitutionGroup(timeCS)

usesTemporalDatum._setSubstitutionGroup(temporalDatum)

AbstractFeatureCollection._setSubstitutionGroup(AbstractFeature)

definitionMember._setSubstitutionGroup(dictionaryEntry)

multiPointDomain._setSubstitutionGroup(domainSet)

multiCurveDomain._setSubstitutionGroup(domainSet)

multiSurfaceDomain._setSubstitutionGroup(domainSet)

multiSolidDomain._setSubstitutionGroup(domainSet)

gridDomain._setSubstitutionGroup(domainSet)

rectifiedGridDomain._setSubstitutionGroup(domainSet)

generalOperationParameter._setSubstitutionGroup(parameter)

MovingObjectStatus._setSubstitutionGroup(AbstractTimeSlice)

Definition._setSubstitutionGroup(AbstractGML)

DynamicFeature._setSubstitutionGroup(AbstractFeature)

EnvelopeWithTimePeriod._setSubstitutionGroup(Envelope)

AbstractGeometricAggregate._setSubstitutionGroup(AbstractGeometry)

AbstractGeometricPrimitive._setSubstitutionGroup(AbstractGeometry)

GeometricComplex._setSubstitutionGroup(AbstractGeometry)

Arc._setSubstitutionGroup(ArcString)

ArcByBulge._setSubstitutionGroup(ArcStringByBulge)

CircleByCenterPoint._setSubstitutionGroup(ArcByCenterPoint)

Bezier._setSubstitutionGroup(BSpline)

Geodesic._setSubstitutionGroup(GeodesicString)

AbstractGriddedSurface._setSubstitutionGroup(AbstractParametricCurveSurface)

Grid._setSubstitutionGroup(AbstractImplicitGeometry)

Observation._setSubstitutionGroup(AbstractFeature)

subject._setSubstitutionGroup(target)

AbstractTimePrimitive._setSubstitutionGroup(AbstractTimeObject)

AbstractTimeComplex._setSubstitutionGroup(AbstractTimeObject)

AbstractTopoPrimitive._setSubstitutionGroup(AbstractTopology)

TopoComplex._setSubstitutionGroup(AbstractTopology)

Boolean_._setSubstitutionGroup(AbstractScalarValue)

BooleanList._setSubstitutionGroup(AbstractScalarValueList)

Category._setSubstitutionGroup(AbstractScalarValue)

Count._setSubstitutionGroup(AbstractScalarValue)

CountList._setSubstitutionGroup(AbstractScalarValueList)

ValueArray._setSubstitutionGroup(CompositeValue)

Length._setSubstitutionGroup(Measure)

Angle._setSubstitutionGroup(Measure)

Scale._setSubstitutionGroup(Measure)

Distance._setSubstitutionGroup(Length)

MD_ImageDescription._setSubstitutionGroup(MD_CoverageDescription)

DQ_TemporalValidity._setSubstitutionGroup(AbstractDQ_TemporalAccuracy)

DQ_TemporalConsistency._setSubstitutionGroup(AbstractDQ_TemporalAccuracy)

DQ_AccuracyOfATimeMeasurement._setSubstitutionGroup(AbstractDQ_TemporalAccuracy)

DQ_QuantitativeAttributeAccuracy._setSubstitutionGroup(AbstractDQ_ThematicAccuracy)

DQ_NonQuantitativeAttributeAccuracy._setSubstitutionGroup(AbstractDQ_ThematicAccuracy)

DQ_ThematicClassificationCorrectness._setSubstitutionGroup(AbstractDQ_ThematicAccuracy)

DQ_RelativeInternalPositionalAccuracy._setSubstitutionGroup(AbstractDQ_PositionalAccuracy)

DQ_GriddedDataPositionalAccuracy._setSubstitutionGroup(AbstractDQ_PositionalAccuracy)

DQ_AbsoluteExternalPositionalAccuracy._setSubstitutionGroup(AbstractDQ_PositionalAccuracy)

DQ_TopologicalConsistency._setSubstitutionGroup(AbstractDQ_LogicalConsistency)

DQ_FormatConsistency._setSubstitutionGroup(AbstractDQ_LogicalConsistency)

DQ_DomainConsistency._setSubstitutionGroup(AbstractDQ_LogicalConsistency)

DQ_ConceptualConsistency._setSubstitutionGroup(AbstractDQ_LogicalConsistency)

DQ_CompletenessOmission._setSubstitutionGroup(AbstractDQ_Completeness)

DQ_CompletenessCommission._setSubstitutionGroup(AbstractDQ_Completeness)

DS_Platform._setSubstitutionGroup(DS_Series)

DS_Sensor._setSubstitutionGroup(DS_Series)

DS_ProductionSeries._setSubstitutionGroup(DS_Series)

DS_StereoMate._setSubstitutionGroup(DS_OtherAggregate)

MD_Georeferenceable._setSubstitutionGroup(MD_GridSpatialRepresentation)

MD_Georectified._setSubstitutionGroup(MD_GridSpatialRepresentation)

AbstractDiscreteCoverage._setSubstitutionGroup(AbstractCoverage)

AbstractContinuousCoverage._setSubstitutionGroup(AbstractFeature)

MultiPointCoverage._setSubstitutionGroup(AbstractDiscreteCoverage)

MultiCurveCoverage._setSubstitutionGroup(AbstractDiscreteCoverage)

MultiSurfaceCoverage._setSubstitutionGroup(AbstractDiscreteCoverage)

MultiSolidCoverage._setSubstitutionGroup(AbstractDiscreteCoverage)

GridCoverage._setSubstitutionGroup(AbstractDiscreteCoverage)

RectifiedGridCoverage._setSubstitutionGroup(AbstractDiscreteCoverage)

priorityLocation._setSubstitutionGroup(location)

FeatureCollection._setSubstitutionGroup(AbstractFeature)

DefinitionCollection._setSubstitutionGroup(Definition)

DefinitionProxy._setSubstitutionGroup(Definition)

Dictionary._setSubstitutionGroup(Definition)

DynamicFeatureCollection._setSubstitutionGroup(DynamicFeature)

MultiGeometry._setSubstitutionGroup(AbstractGeometricAggregate)

MultiPoint._setSubstitutionGroup(AbstractGeometricAggregate)

MultiCurve._setSubstitutionGroup(AbstractGeometricAggregate)

MultiSurface._setSubstitutionGroup(AbstractGeometricAggregate)

MultiSolid._setSubstitutionGroup(AbstractGeometricAggregate)

Point._setSubstitutionGroup(AbstractGeometricPrimitive)

AbstractCurve._setSubstitutionGroup(AbstractGeometricPrimitive)

AbstractSurface._setSubstitutionGroup(AbstractGeometricPrimitive)

Circle._setSubstitutionGroup(Arc)

Cone._setSubstitutionGroup(AbstractGriddedSurface)

Cylinder._setSubstitutionGroup(AbstractGriddedSurface)

Sphere._setSubstitutionGroup(AbstractGriddedSurface)

AbstractSolid._setSubstitutionGroup(AbstractGeometricPrimitive)

RectifiedGrid._setSubstitutionGroup(Grid)

DirectedObservation._setSubstitutionGroup(Observation)

AbstractTimeGeometricPrimitive._setSubstitutionGroup(AbstractTimePrimitive)

TimeReferenceSystem._setSubstitutionGroup(Definition)

AbstractTimeTopologyPrimitive._setSubstitutionGroup(AbstractTimePrimitive)

TimeTopologyComplex._setSubstitutionGroup(AbstractTimeComplex)

Node._setSubstitutionGroup(AbstractTopoPrimitive)

Edge._setSubstitutionGroup(AbstractTopoPrimitive)

Face._setSubstitutionGroup(AbstractTopoPrimitive)

TopoSolid._setSubstitutionGroup(AbstractTopoPrimitive)

UnitDefinition._setSubstitutionGroup(Definition)

CategoryList._setSubstitutionGroup(AbstractScalarValueList)

Quantity._setSubstitutionGroup(AbstractScalarValue)

QuantityList._setSubstitutionGroup(AbstractScalarValueList)

CountExtent._setSubstitutionGroup(AbstractValue)

AbstractCoordinateOperation._setSubstitutionGroup(Definition)

AbstractSingleOperation._setSubstitutionGroup(AbstractCoordinateOperation)

OperationMethod._setSubstitutionGroup(Definition)

AbstractGeneralOperationParameter._setSubstitutionGroup(Definition)

AbstractSingleCRS._setSubstitutionGroup(AbstractCRS)

CoordinateSystemAxis._setSubstitutionGroup(Definition)

AbstractCoordinateSystem._setSubstitutionGroup(Definition)

AbstractDatum._setSubstitutionGroup(Definition)

Ellipsoid._setSubstitutionGroup(Definition)

PrimeMeridian._setSubstitutionGroup(Definition)

AbstractOperation._setSubstitutionGroup(AbstractSingleOperation)

LineString._setSubstitutionGroup(AbstractCurve)

Polygon._setSubstitutionGroup(AbstractSurface)

AbstractRing._setSubstitutionGroup(AbstractCurve)

CompositeCurve._setSubstitutionGroup(AbstractCurve)

CompositeSurface._setSubstitutionGroup(AbstractSurface)

CompositeSolid._setSubstitutionGroup(AbstractSolid)

Curve._setSubstitutionGroup(AbstractCurve)

OrientableCurve._setSubstitutionGroup(AbstractCurve)

Surface._setSubstitutionGroup(AbstractSurface)

OrientableSurface._setSubstitutionGroup(AbstractSurface)

PolyhedralSurface._setSubstitutionGroup(Surface)

TriangulatedSurface._setSubstitutionGroup(Surface)

Solid._setSubstitutionGroup(AbstractSolid)

Shell._setSubstitutionGroup(AbstractSurface)

DirectedObservationAtDistance._setSubstitutionGroup(DirectedObservation)

AbstractCRS._setSubstitutionGroup(Definition)

TimeInstant._setSubstitutionGroup(AbstractTimeGeometricPrimitive)

TimePeriod._setSubstitutionGroup(AbstractTimeGeometricPrimitive)

TimeCoordinateSystem._setSubstitutionGroup(TimeReferenceSystem)

TimeCalendar._setSubstitutionGroup(TimeReferenceSystem)

TimeClock._setSubstitutionGroup(TimeReferenceSystem)

TimeOrdinalReferenceSystem._setSubstitutionGroup(TimeReferenceSystem)

TimeNode._setSubstitutionGroup(AbstractTimeTopologyPrimitive)

TimeEdge._setSubstitutionGroup(AbstractTimeTopologyPrimitive)

BaseUnit._setSubstitutionGroup(UnitDefinition)

DerivedUnit._setSubstitutionGroup(UnitDefinition)

ConventionalUnit._setSubstitutionGroup(UnitDefinition)

CategoryExtent._setSubstitutionGroup(AbstractValue)

QuantityExtent._setSubstitutionGroup(AbstractValue)

AbstractGeneralConversion._setSubstitutionGroup(AbstractOperation)

AbstractGeneralTransformation._setSubstitutionGroup(AbstractOperation)

ConcatenatedOperation._setSubstitutionGroup(AbstractCoordinateOperation)

PassThroughOperation._setSubstitutionGroup(AbstractSingleOperation)

OperationParameter._setSubstitutionGroup(AbstractGeneralOperationParameter)

OperationParameterGroup._setSubstitutionGroup(AbstractGeneralOperationParameter)

AbstractGeneralDerivedCRS._setSubstitutionGroup(AbstractSingleCRS)

CompoundCRS._setSubstitutionGroup(AbstractCRS)

GeodeticCRS._setSubstitutionGroup(AbstractSingleCRS)

VerticalCRS._setSubstitutionGroup(AbstractSingleCRS)

EngineeringCRS._setSubstitutionGroup(AbstractSingleCRS)

ImageCRS._setSubstitutionGroup(AbstractSingleCRS)

TemporalCRS._setSubstitutionGroup(AbstractSingleCRS)

EllipsoidalCS._setSubstitutionGroup(AbstractCoordinateSystem)

CartesianCS._setSubstitutionGroup(AbstractCoordinateSystem)

VerticalCS._setSubstitutionGroup(AbstractCoordinateSystem)

TimeCS._setSubstitutionGroup(AbstractCoordinateSystem)

LinearCS._setSubstitutionGroup(AbstractCoordinateSystem)

UserDefinedCS._setSubstitutionGroup(AbstractCoordinateSystem)

SphericalCS._setSubstitutionGroup(AbstractCoordinateSystem)

PolarCS._setSubstitutionGroup(AbstractCoordinateSystem)

CylindricalCS._setSubstitutionGroup(AbstractCoordinateSystem)

AffineCS._setSubstitutionGroup(AbstractCoordinateSystem)

GeodeticDatum._setSubstitutionGroup(AbstractDatum)

EngineeringDatum._setSubstitutionGroup(AbstractDatum)

ImageDatum._setSubstitutionGroup(AbstractDatum)

VerticalDatum._setSubstitutionGroup(AbstractDatum)

TemporalCS._setSubstitutionGroup(AbstractCoordinateSystem)

ObliqueCartesianCS._setSubstitutionGroup(AbstractCoordinateSystem)

GeographicCRS._setSubstitutionGroup(AbstractSingleCRS)

GeocentricCRS._setSubstitutionGroup(AbstractSingleCRS)

LinearRing._setSubstitutionGroup(AbstractRing)

Ring._setSubstitutionGroup(AbstractRing)

Tin._setSubstitutionGroup(TriangulatedSurface)

Conversion._setSubstitutionGroup(AbstractGeneralConversion)

Transformation._setSubstitutionGroup(AbstractGeneralTransformation)

ProjectedCRS._setSubstitutionGroup(AbstractGeneralDerivedCRS)

DerivedCRS._setSubstitutionGroup(AbstractGeneralDerivedCRS)

TemporalDatum._setSubstitutionGroup(AbstractDatum)
