# ./ome_schema.py
# -*- coding: utf-8 -*-
# PyXB bindings for NM:b0644015d26f3c1073fb3fe883cedd8da00569f4
# Generated 2017-02-14 13:51:21.108802 by PyXB version 1.2.5 using Python 2.7.12.final.0
# Namespace http://www.openmicroscopy.org/Schemas/OME/2016-06

from __future__ import unicode_literals
import pyxb
import pyxb.binding
import pyxb.binding.saxer
import io
import pyxb.utils.utility
import pyxb.utils.domutils
import sys
import pyxb.utils.six as _six
# Unique identifier for bindings created at the same time
_GenerationUID = pyxb.utils.utility.UniqueIdentifier('urn:uuid:a9ef9b74-f2bc-11e6-9b87-d850e6bacf71')

# Version of PyXB used to generate the bindings
_PyXBVersion = '1.2.5'
# 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

# NOTE: All namespace declarations are reserved within the binding
Namespace = pyxb.namespace.NamespaceForURI('http://www.openmicroscopy.org/Schemas/OME/2016-06', create_if_missing=True)
Namespace.configureCategories(['typeBinding', 'elementBinding'])

def CreateFromDocument (xml_text, default_namespace=None, location_base=None):
    """Parse the given XML and use the document element to create a
    Python instance.

    @param xml_text An XML document.  This should be data (Python 2
    str or Python 3 bytes), or a text (Python 2 unicode or Python 3
    str) in the L{pyxb._InputEncoding} encoding.

    @keyword default_namespace The L{pyxb.Namespace} instance to use as the
    default namespace where there is no default namespace in scope.
    If unspecified or C{None}, the namespace of the module containing
    this function will be used.

    @keyword location_base: An object to be recorded as the base of all
    L{pyxb.utils.utility.Location} instances associated with events and
    objects handled by the parser.  You might pass the URI from which
    the document was obtained.
    """

    if pyxb.XMLStyle_saxer != pyxb._XMLStyle:
        dom = pyxb.utils.domutils.StringToDOM(xml_text)
        return CreateFromDOM(dom.documentElement, default_namespace=default_namespace)
    if default_namespace is None:
        default_namespace = Namespace.fallbackNamespace()
    saxer = pyxb.binding.saxer.make_parser(fallback_namespace=default_namespace, location_base=location_base)
    handler = saxer.getContentHandler()
    xmld = xml_text
    if isinstance(xmld, _six.text_type):
        xmld = xmld.encode(pyxb._InputEncoding)
    saxer.parse(io.BytesIO(xmld))
    instance = handler.rootObject()
    return instance

def CreateFromDOM (node, default_namespace=None):
    """Create a Python instance from the given DOM node.
    The node tag must correspond to an element declaration in this module.

    @deprecated: Forcing use of DOM interface is unnecessary; use L{CreateFromDocument}."""
    if default_namespace is None:
        default_namespace = Namespace.fallbackNamespace()
    return pyxb.binding.basis.element.AnyCreateFromDOM(node, default_namespace)


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

    """An atomic simple type."""

    _ExpandedName = None
    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 274, 10)
    _Documentation = None
STD_ANON._CF_whiteSpace = pyxb.binding.facets.CF_whiteSpace(value=pyxb.binding.facets._WhiteSpace_enum.preserve)
STD_ANON._InitializeFacetMap(STD_ANON._CF_whiteSpace)
_module_typeBindings.STD_ANON = STD_ANON

# 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('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 358, 8)
    _Documentation = None
STD_ANON_._CF_enumeration = pyxb.binding.facets.CF_enumeration(value_datatype=STD_ANON_, enum_prefix=None)
STD_ANON_.XYZCT = STD_ANON_._CF_enumeration.addEnumeration(unicode_value='XYZCT', tag='XYZCT')
STD_ANON_.XYZTC = STD_ANON_._CF_enumeration.addEnumeration(unicode_value='XYZTC', tag='XYZTC')
STD_ANON_.XYCTZ = STD_ANON_._CF_enumeration.addEnumeration(unicode_value='XYCTZ', tag='XYCTZ')
STD_ANON_.XYCZT = STD_ANON_._CF_enumeration.addEnumeration(unicode_value='XYCZT', tag='XYCZT')
STD_ANON_.XYTCZ = STD_ANON_._CF_enumeration.addEnumeration(unicode_value='XYTCZ', tag='XYTCZ')
STD_ANON_.XYTZC = STD_ANON_._CF_enumeration.addEnumeration(unicode_value='XYTZC', tag='XYTZC')
STD_ANON_._InitializeFacetMap(STD_ANON_._CF_enumeration)
_module_typeBindings.STD_ANON_ = STD_ANON_

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

    """An atomic simple type."""

    _ExpandedName = None
    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 641, 8)
    _Documentation = None
STD_ANON_2._CF_enumeration = pyxb.binding.facets.CF_enumeration(value_datatype=STD_ANON_2, enum_prefix=None)
STD_ANON_2.Transmitted = STD_ANON_2._CF_enumeration.addEnumeration(unicode_value='Transmitted', tag='Transmitted')
STD_ANON_2.Epifluorescence = STD_ANON_2._CF_enumeration.addEnumeration(unicode_value='Epifluorescence', tag='Epifluorescence')
STD_ANON_2.Oblique = STD_ANON_2._CF_enumeration.addEnumeration(unicode_value='Oblique', tag='Oblique')
STD_ANON_2.NonLinear = STD_ANON_2._CF_enumeration.addEnumeration(unicode_value='NonLinear', tag='NonLinear')
STD_ANON_2.Other = STD_ANON_2._CF_enumeration.addEnumeration(unicode_value='Other', tag='Other')
STD_ANON_2._InitializeFacetMap(STD_ANON_2._CF_enumeration)
_module_typeBindings.STD_ANON_2 = STD_ANON_2

# 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('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 670, 8)
    _Documentation = None
STD_ANON_3._CF_enumeration = pyxb.binding.facets.CF_enumeration(value_datatype=STD_ANON_3, enum_prefix=None)
STD_ANON_3.WideField = STD_ANON_3._CF_enumeration.addEnumeration(unicode_value='WideField', tag='WideField')
STD_ANON_3.LaserScanningConfocalMicroscopy = STD_ANON_3._CF_enumeration.addEnumeration(unicode_value='LaserScanningConfocalMicroscopy', tag='LaserScanningConfocalMicroscopy')
STD_ANON_3.SpinningDiskConfocal = STD_ANON_3._CF_enumeration.addEnumeration(unicode_value='SpinningDiskConfocal', tag='SpinningDiskConfocal')
STD_ANON_3.SlitScanConfocal = STD_ANON_3._CF_enumeration.addEnumeration(unicode_value='SlitScanConfocal', tag='SlitScanConfocal')
STD_ANON_3.MultiPhotonMicroscopy = STD_ANON_3._CF_enumeration.addEnumeration(unicode_value='MultiPhotonMicroscopy', tag='MultiPhotonMicroscopy')
STD_ANON_3.StructuredIllumination = STD_ANON_3._CF_enumeration.addEnumeration(unicode_value='StructuredIllumination', tag='StructuredIllumination')
STD_ANON_3.SingleMoleculeImaging = STD_ANON_3._CF_enumeration.addEnumeration(unicode_value='SingleMoleculeImaging', tag='SingleMoleculeImaging')
STD_ANON_3.TotalInternalReflection = STD_ANON_3._CF_enumeration.addEnumeration(unicode_value='TotalInternalReflection', tag='TotalInternalReflection')
STD_ANON_3.FluorescenceLifetime = STD_ANON_3._CF_enumeration.addEnumeration(unicode_value='FluorescenceLifetime', tag='FluorescenceLifetime')
STD_ANON_3.SpectralImaging = STD_ANON_3._CF_enumeration.addEnumeration(unicode_value='SpectralImaging', tag='SpectralImaging')
STD_ANON_3.FluorescenceCorrelationSpectroscopy = STD_ANON_3._CF_enumeration.addEnumeration(unicode_value='FluorescenceCorrelationSpectroscopy', tag='FluorescenceCorrelationSpectroscopy')
STD_ANON_3.NearFieldScanningOpticalMicroscopy = STD_ANON_3._CF_enumeration.addEnumeration(unicode_value='NearFieldScanningOpticalMicroscopy', tag='NearFieldScanningOpticalMicroscopy')
STD_ANON_3.SecondHarmonicGenerationImaging = STD_ANON_3._CF_enumeration.addEnumeration(unicode_value='SecondHarmonicGenerationImaging', tag='SecondHarmonicGenerationImaging')
STD_ANON_3.PALM = STD_ANON_3._CF_enumeration.addEnumeration(unicode_value='PALM', tag='PALM')
STD_ANON_3.STORM = STD_ANON_3._CF_enumeration.addEnumeration(unicode_value='STORM', tag='STORM')
STD_ANON_3.STED = STD_ANON_3._CF_enumeration.addEnumeration(unicode_value='STED', tag='STED')
STD_ANON_3.TIRF = STD_ANON_3._CF_enumeration.addEnumeration(unicode_value='TIRF', tag='TIRF')
STD_ANON_3.FSM = STD_ANON_3._CF_enumeration.addEnumeration(unicode_value='FSM', tag='FSM')
STD_ANON_3.LCM = STD_ANON_3._CF_enumeration.addEnumeration(unicode_value='LCM', tag='LCM')
STD_ANON_3.Other = STD_ANON_3._CF_enumeration.addEnumeration(unicode_value='Other', tag='Other')
STD_ANON_3.BrightField = STD_ANON_3._CF_enumeration.addEnumeration(unicode_value='BrightField', tag='BrightField')
STD_ANON_3.SweptFieldConfocal = STD_ANON_3._CF_enumeration.addEnumeration(unicode_value='SweptFieldConfocal', tag='SweptFieldConfocal')
STD_ANON_3.SPIM = STD_ANON_3._CF_enumeration.addEnumeration(unicode_value='SPIM', tag='SPIM')
STD_ANON_3._InitializeFacetMap(STD_ANON_3._CF_enumeration)
_module_typeBindings.STD_ANON_3 = STD_ANON_3

# 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('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 704, 8)
    _Documentation = None
STD_ANON_4._CF_enumeration = pyxb.binding.facets.CF_enumeration(value_datatype=STD_ANON_4, enum_prefix=None)
STD_ANON_4.Brightfield = STD_ANON_4._CF_enumeration.addEnumeration(unicode_value='Brightfield', tag='Brightfield')
STD_ANON_4.Phase = STD_ANON_4._CF_enumeration.addEnumeration(unicode_value='Phase', tag='Phase')
STD_ANON_4.DIC = STD_ANON_4._CF_enumeration.addEnumeration(unicode_value='DIC', tag='DIC')
STD_ANON_4.HoffmanModulation = STD_ANON_4._CF_enumeration.addEnumeration(unicode_value='HoffmanModulation', tag='HoffmanModulation')
STD_ANON_4.ObliqueIllumination = STD_ANON_4._CF_enumeration.addEnumeration(unicode_value='ObliqueIllumination', tag='ObliqueIllumination')
STD_ANON_4.PolarizedLight = STD_ANON_4._CF_enumeration.addEnumeration(unicode_value='PolarizedLight', tag='PolarizedLight')
STD_ANON_4.Darkfield = STD_ANON_4._CF_enumeration.addEnumeration(unicode_value='Darkfield', tag='Darkfield')
STD_ANON_4.Fluorescence = STD_ANON_4._CF_enumeration.addEnumeration(unicode_value='Fluorescence', tag='Fluorescence')
STD_ANON_4.Other = STD_ANON_4._CF_enumeration.addEnumeration(unicode_value='Other', tag='Other')
STD_ANON_4._InitializeFacetMap(STD_ANON_4._CF_enumeration)
_module_typeBindings.STD_ANON_4 = STD_ANON_4

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

    """An atomic simple type."""

    _ExpandedName = None
    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 937, 10)
    _Documentation = None
STD_ANON_5._CF_whiteSpace = pyxb.binding.facets.CF_whiteSpace(value=pyxb.binding.facets._WhiteSpace_enum.preserve)
STD_ANON_5._InitializeFacetMap(STD_ANON_5._CF_whiteSpace)
_module_typeBindings.STD_ANON_5 = STD_ANON_5

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

    """An atomic simple type."""

    _ExpandedName = None
    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 960, 12)
    _Documentation = None
STD_ANON_6._CF_enumeration = pyxb.binding.facets.CF_enumeration(value_datatype=STD_ANON_6, enum_prefix=None)
STD_ANON_6.FRAP = STD_ANON_6._CF_enumeration.addEnumeration(unicode_value='FRAP', tag='FRAP')
STD_ANON_6.FLIP = STD_ANON_6._CF_enumeration.addEnumeration(unicode_value='FLIP', tag='FLIP')
STD_ANON_6.InverseFRAP = STD_ANON_6._CF_enumeration.addEnumeration(unicode_value='InverseFRAP', tag='InverseFRAP')
STD_ANON_6.Photoablation = STD_ANON_6._CF_enumeration.addEnumeration(unicode_value='Photoablation', tag='Photoablation')
STD_ANON_6.Photoactivation = STD_ANON_6._CF_enumeration.addEnumeration(unicode_value='Photoactivation', tag='Photoactivation')
STD_ANON_6.Uncaging = STD_ANON_6._CF_enumeration.addEnumeration(unicode_value='Uncaging', tag='Uncaging')
STD_ANON_6.OpticalTrapping = STD_ANON_6._CF_enumeration.addEnumeration(unicode_value='OpticalTrapping', tag='OpticalTrapping')
STD_ANON_6.Other = STD_ANON_6._CF_enumeration.addEnumeration(unicode_value='Other', tag='Other')
STD_ANON_6._InitializeFacetMap(STD_ANON_6._CF_enumeration)
_module_typeBindings.STD_ANON_6 = STD_ANON_6

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

    """An atomic simple type."""

    _ExpandedName = None
    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1025, 12)
    _Documentation = None
STD_ANON_7._CF_enumeration = pyxb.binding.facets.CF_enumeration(value_datatype=STD_ANON_7, enum_prefix=None)
STD_ANON_7.Upright = STD_ANON_7._CF_enumeration.addEnumeration(unicode_value='Upright', tag='Upright')
STD_ANON_7.Inverted = STD_ANON_7._CF_enumeration.addEnumeration(unicode_value='Inverted', tag='Inverted')
STD_ANON_7.Dissection = STD_ANON_7._CF_enumeration.addEnumeration(unicode_value='Dissection', tag='Dissection')
STD_ANON_7.Electrophysiology = STD_ANON_7._CF_enumeration.addEnumeration(unicode_value='Electrophysiology', tag='Electrophysiology')
STD_ANON_7.Other = STD_ANON_7._CF_enumeration.addEnumeration(unicode_value='Other', tag='Other')
STD_ANON_7._InitializeFacetMap(STD_ANON_7._CF_enumeration)
_module_typeBindings.STD_ANON_7 = STD_ANON_7

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

    """An atomic simple type."""

    _ExpandedName = None
    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1119, 10)
    _Documentation = None
STD_ANON_8._CF_whiteSpace = pyxb.binding.facets.CF_whiteSpace(value=pyxb.binding.facets._WhiteSpace_enum.preserve)
STD_ANON_8._InitializeFacetMap(STD_ANON_8._CF_whiteSpace)
_module_typeBindings.STD_ANON_8 = STD_ANON_8

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

    """An atomic simple type."""

    _ExpandedName = None
    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1159, 10)
    _Documentation = None
STD_ANON_9._CF_whiteSpace = pyxb.binding.facets.CF_whiteSpace(value=pyxb.binding.facets._WhiteSpace_enum.preserve)
STD_ANON_9._InitializeFacetMap(STD_ANON_9._CF_whiteSpace)
_module_typeBindings.STD_ANON_9 = STD_ANON_9

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

    """An atomic simple type."""

    _ExpandedName = None
    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1222, 10)
    _Documentation = None
STD_ANON_10._CF_whiteSpace = pyxb.binding.facets.CF_whiteSpace(value=pyxb.binding.facets._WhiteSpace_enum.preserve)
STD_ANON_10._InitializeFacetMap(STD_ANON_10._CF_whiteSpace)
_module_typeBindings.STD_ANON_10 = STD_ANON_10

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

    """An atomic simple type."""

    _ExpandedName = None
    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1270, 10)
    _Documentation = None
STD_ANON_11._CF_whiteSpace = pyxb.binding.facets.CF_whiteSpace(value=pyxb.binding.facets._WhiteSpace_enum.preserve)
STD_ANON_11._InitializeFacetMap(STD_ANON_11._CF_whiteSpace)
_module_typeBindings.STD_ANON_11 = STD_ANON_11

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

    """An atomic simple type."""

    _ExpandedName = None
    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1293, 12)
    _Documentation = None
STD_ANON_12._CF_enumeration = pyxb.binding.facets.CF_enumeration(value_datatype=STD_ANON_12, enum_prefix=None)
STD_ANON_12.FP = STD_ANON_12._CF_enumeration.addEnumeration(unicode_value='FP', tag='FP')
STD_ANON_12.FRET = STD_ANON_12._CF_enumeration.addEnumeration(unicode_value='FRET', tag='FRET')
STD_ANON_12.TimeLapse = STD_ANON_12._CF_enumeration.addEnumeration(unicode_value='TimeLapse', tag='TimeLapse')
STD_ANON_12.FourDPlus = STD_ANON_12._CF_enumeration.addEnumeration(unicode_value='FourDPlus', tag='FourDPlus')
STD_ANON_12.Screen = STD_ANON_12._CF_enumeration.addEnumeration(unicode_value='Screen', tag='Screen')
STD_ANON_12.Immunocytochemistry = STD_ANON_12._CF_enumeration.addEnumeration(unicode_value='Immunocytochemistry', tag='Immunocytochemistry')
STD_ANON_12.Immunofluorescence = STD_ANON_12._CF_enumeration.addEnumeration(unicode_value='Immunofluorescence', tag='Immunofluorescence')
STD_ANON_12.FISH = STD_ANON_12._CF_enumeration.addEnumeration(unicode_value='FISH', tag='FISH')
STD_ANON_12.Electrophysiology = STD_ANON_12._CF_enumeration.addEnumeration(unicode_value='Electrophysiology', tag='Electrophysiology')
STD_ANON_12.IonImaging = STD_ANON_12._CF_enumeration.addEnumeration(unicode_value='IonImaging', tag='IonImaging')
STD_ANON_12.Colocalization = STD_ANON_12._CF_enumeration.addEnumeration(unicode_value='Colocalization', tag='Colocalization')
STD_ANON_12.PGIDocumentation = STD_ANON_12._CF_enumeration.addEnumeration(unicode_value='PGIDocumentation', tag='PGIDocumentation')
STD_ANON_12.FluorescenceLifetime = STD_ANON_12._CF_enumeration.addEnumeration(unicode_value='FluorescenceLifetime', tag='FluorescenceLifetime')
STD_ANON_12.SpectralImaging = STD_ANON_12._CF_enumeration.addEnumeration(unicode_value='SpectralImaging', tag='SpectralImaging')
STD_ANON_12.Photobleaching = STD_ANON_12._CF_enumeration.addEnumeration(unicode_value='Photobleaching', tag='Photobleaching')
STD_ANON_12.SPIM = STD_ANON_12._CF_enumeration.addEnumeration(unicode_value='SPIM', tag='SPIM')
STD_ANON_12.Other = STD_ANON_12._CF_enumeration.addEnumeration(unicode_value='Other', tag='Other')
STD_ANON_12._InitializeFacetMap(STD_ANON_12._CF_enumeration)
_module_typeBindings.STD_ANON_12 = STD_ANON_12

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

    """An atomic simple type."""

    _ExpandedName = None
    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1394, 10)
    _Documentation = None
STD_ANON_13._CF_whiteSpace = pyxb.binding.facets.CF_whiteSpace(value=pyxb.binding.facets._WhiteSpace_enum.preserve)
STD_ANON_13._InitializeFacetMap(STD_ANON_13._CF_whiteSpace)
_module_typeBindings.STD_ANON_13 = STD_ANON_13

# Atomic simple type: {http://www.openmicroscopy.org/Schemas/OME/2016-06}Hex40
class Hex40 (pyxb.binding.datatypes.hexBinary):

    """
        Binary contents coded in hexadecimal (20 characters long)
      """

    _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'Hex40')
    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1467, 2)
    _Documentation = '\n        Binary contents coded in hexadecimal (20 characters long)\n      '
Hex40._CF_length = pyxb.binding.facets.CF_length(value=pyxb.binding.datatypes.nonNegativeInteger(20))
Hex40._InitializeFacetMap(Hex40._CF_length)
Namespace.addCategoryObject('typeBinding', 'Hex40', Hex40)
_module_typeBindings.Hex40 = Hex40

# Atomic simple type: {http://www.openmicroscopy.org/Schemas/OME/2016-06}NonNegativeFloat
class NonNegativeFloat (pyxb.binding.datatypes.float):

    """
        A simple type that restricts the value to a float between >=0 and max 32-bit float {i.e. (2−2^-23) × 2^27 ≈ 3.4 × 10^38}
      """

    _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'NonNegativeFloat')
    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1477, 2)
    _Documentation = '\n        A simple type that restricts the value to a float between >=0 and max 32-bit float {i.e. (2\u22122^-23) \xd7 2^27 \u2248 3.4 \xd7 10^38}\n      '
NonNegativeFloat._CF_minInclusive = pyxb.binding.facets.CF_minInclusive(value_datatype=NonNegativeFloat, value=pyxb.binding.datatypes.float(0.0))
NonNegativeFloat._InitializeFacetMap(NonNegativeFloat._CF_minInclusive)
Namespace.addCategoryObject('typeBinding', 'NonNegativeFloat', NonNegativeFloat)
_module_typeBindings.NonNegativeFloat = NonNegativeFloat

# Atomic simple type: {http://www.openmicroscopy.org/Schemas/OME/2016-06}NonNegativeLong
class NonNegativeLong (pyxb.binding.datatypes.long):

    """
        A simple type that restricts the value to a long between 0 and 9223372036854775807 (inclusive).
      """

    _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'NonNegativeLong')
    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1487, 2)
    _Documentation = '\n        A simple type that restricts the value to a long between 0 and 9223372036854775807 (inclusive).\n      '
NonNegativeLong._CF_minInclusive = pyxb.binding.facets.CF_minInclusive(value_datatype=NonNegativeLong, value=pyxb.binding.datatypes.long(0))
NonNegativeLong._InitializeFacetMap(NonNegativeLong._CF_minInclusive)
Namespace.addCategoryObject('typeBinding', 'NonNegativeLong', NonNegativeLong)
_module_typeBindings.NonNegativeLong = NonNegativeLong

# Atomic simple type: {http://www.openmicroscopy.org/Schemas/OME/2016-06}NonNegativeInt
class NonNegativeInt (pyxb.binding.datatypes.int):

    """
        A simple type that restricts the value to an integer between 0 and 2,147,483,647 (inclusive).
      """

    _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'NonNegativeInt')
    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1497, 2)
    _Documentation = '\n        A simple type that restricts the value to an integer between 0 and 2,147,483,647 (inclusive).\n      '
NonNegativeInt._CF_minInclusive = pyxb.binding.facets.CF_minInclusive(value_datatype=NonNegativeInt, value=pyxb.binding.datatypes.int(0))
NonNegativeInt._InitializeFacetMap(NonNegativeInt._CF_minInclusive)
Namespace.addCategoryObject('typeBinding', 'NonNegativeInt', NonNegativeInt)
_module_typeBindings.NonNegativeInt = NonNegativeInt

# Atomic simple type: {http://www.openmicroscopy.org/Schemas/OME/2016-06}PositiveInt
class PositiveInt (pyxb.binding.datatypes.int):

    """
        A simple type that restricts the value to an integer between 1 and 2,147,483,647 (inclusive).
      """

    _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'PositiveInt')
    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1507, 2)
    _Documentation = '\n        A simple type that restricts the value to an integer between 1 and 2,147,483,647 (inclusive).\n      '
PositiveInt._CF_minInclusive = pyxb.binding.facets.CF_minInclusive(value_datatype=PositiveInt, value=pyxb.binding.datatypes.int(1))
PositiveInt._InitializeFacetMap(PositiveInt._CF_minInclusive)
Namespace.addCategoryObject('typeBinding', 'PositiveInt', PositiveInt)
_module_typeBindings.PositiveInt = PositiveInt

# Atomic simple type: {http://www.openmicroscopy.org/Schemas/OME/2016-06}PositiveFloat
class PositiveFloat (pyxb.binding.datatypes.float):

    """
        A simple type that restricts the value to a float between >0 and max 32-bit float {i.e. (2−2^-23) × 2^27 ≈ 3.4 × 10^38}
      """

    _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'PositiveFloat')
    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1517, 2)
    _Documentation = '\n        A simple type that restricts the value to a float between >0 and max 32-bit float {i.e. (2\u22122^-23) \xd7 2^27 \u2248 3.4 \xd7 10^38}\n      '
PositiveFloat._CF_minExclusive = pyxb.binding.facets.CF_minExclusive(value_datatype=pyxb.binding.datatypes.float, value=pyxb.binding.datatypes._fp(0.0))
PositiveFloat._InitializeFacetMap(PositiveFloat._CF_minExclusive)
Namespace.addCategoryObject('typeBinding', 'PositiveFloat', PositiveFloat)
_module_typeBindings.PositiveFloat = PositiveFloat

# Atomic simple type: {http://www.openmicroscopy.org/Schemas/OME/2016-06}PercentFraction
class PercentFraction (pyxb.binding.datatypes.float):

    """
        A simple type that restricts the value to a float between 0 and 1 (inclusive).
      """

    _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'PercentFraction')
    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1527, 2)
    _Documentation = '\n        A simple type that restricts the value to a float between 0 and 1 (inclusive).\n      '
PercentFraction._CF_minInclusive = pyxb.binding.facets.CF_minInclusive(value_datatype=PercentFraction, value=pyxb.binding.datatypes.float(0.0))
PercentFraction._CF_maxInclusive = pyxb.binding.facets.CF_maxInclusive(value_datatype=PercentFraction, value=pyxb.binding.datatypes.float(1.0))
PercentFraction._InitializeFacetMap(PercentFraction._CF_minInclusive,
   PercentFraction._CF_maxInclusive)
Namespace.addCategoryObject('typeBinding', 'PercentFraction', PercentFraction)
_module_typeBindings.PercentFraction = PercentFraction

# Atomic simple type: {http://www.openmicroscopy.org/Schemas/OME/2016-06}UniversallyUniqueIdentifier
class UniversallyUniqueIdentifier (pyxb.binding.datatypes.anyURI):

    """
        This is a unique ID for the file but does not conform to the ID pattern used in the rest of the file.
        The rest of the IDs are either an full LSID or an internal ID which is a string that is simply unique in this file.
        As the UniversallyUniqueIdentifier is used from outside this file to identify it having the same ID in another file could cause problems.
        A UUID is 32 hexadecimal digits, in 5 groups, 8-4-4-4-12, separated by hyphens
        e.g. urn:uuid:3e450fae-b8f2-4d35-aa54-702168b2487f
        There are methods to generate these in most modern languages.
        http://www.ietf.org/rfc/rfc4122.txt
      """

    _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'UniversallyUniqueIdentifier')
    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1538, 2)
    _Documentation = '\n        This is a unique ID for the file but does not conform to the ID pattern used in the rest of the file.\n        The rest of the IDs are either an full LSID or an internal ID which is a string that is simply unique in this file.\n        As the UniversallyUniqueIdentifier is used from outside this file to identify it having the same ID in another file could cause problems.\n        A UUID is 32 hexadecimal digits, in 5 groups, 8-4-4-4-12, separated by hyphens\n        e.g. urn:uuid:3e450fae-b8f2-4d35-aa54-702168b2487f\n        There are methods to generate these in most modern languages.\n        http://www.ietf.org/rfc/rfc4122.txt\n      '
UniversallyUniqueIdentifier._CF_pattern = pyxb.binding.facets.CF_pattern()
UniversallyUniqueIdentifier._CF_pattern.addPattern(pattern='(urn:uuid:[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12})')
UniversallyUniqueIdentifier._InitializeFacetMap(UniversallyUniqueIdentifier._CF_pattern)
Namespace.addCategoryObject('typeBinding', 'UniversallyUniqueIdentifier', UniversallyUniqueIdentifier)
_module_typeBindings.UniversallyUniqueIdentifier = UniversallyUniqueIdentifier

# Atomic simple type: {http://www.openmicroscopy.org/Schemas/OME/2016-06}Binning
class Binning (pyxb.binding.datatypes.string, pyxb.binding.basis.enumeration_mixin):

    """
        Represents the number of pixels that are combined to form larger pixels. {used:CCD,EMCCD}
      """

    _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'Binning')
    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1582, 2)
    _Documentation = '\n        Represents the number of pixels that are combined to form larger pixels. {used:CCD,EMCCD}\n      '
Binning._CF_enumeration = pyxb.binding.facets.CF_enumeration(value_datatype=Binning, enum_prefix=None)
Binning.n1x1 = Binning._CF_enumeration.addEnumeration(unicode_value='1x1', tag='n1x1')
Binning.n2x2 = Binning._CF_enumeration.addEnumeration(unicode_value='2x2', tag='n2x2')
Binning.n4x4 = Binning._CF_enumeration.addEnumeration(unicode_value='4x4', tag='n4x4')
Binning.n8x8 = Binning._CF_enumeration.addEnumeration(unicode_value='8x8', tag='n8x8')
Binning.Other = Binning._CF_enumeration.addEnumeration(unicode_value='Other', tag='Other')
Binning._InitializeFacetMap(Binning._CF_enumeration)
Namespace.addCategoryObject('typeBinding', 'Binning', Binning)
_module_typeBindings.Binning = Binning

# Atomic simple type: {http://www.openmicroscopy.org/Schemas/OME/2016-06}FontFamily
class FontFamily (pyxb.binding.datatypes.string, pyxb.binding.basis.enumeration_mixin):

    """
        The font family used to draw the text. [enumeration]
        Note: these values are all lower case so they match
        the standard HTML/CSS values. "fantasy" has been
        included for completeness we do not recommended its
        regular use.
      """

    _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'FontFamily')
    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1632, 2)
    _Documentation = '\n        The font family used to draw the text. [enumeration]\n        Note: these values are all lower case so they match\n        the standard HTML/CSS values. "fantasy" has been\n        included for completeness we do not recommended its\n        regular use.\n      '
FontFamily._CF_enumeration = pyxb.binding.facets.CF_enumeration(value_datatype=FontFamily, enum_prefix=None)
FontFamily.serif = FontFamily._CF_enumeration.addEnumeration(unicode_value='serif', tag='serif')
FontFamily.sans_serif = FontFamily._CF_enumeration.addEnumeration(unicode_value='sans-serif', tag='sans_serif')
FontFamily.cursive = FontFamily._CF_enumeration.addEnumeration(unicode_value='cursive', tag='cursive')
FontFamily.fantasy = FontFamily._CF_enumeration.addEnumeration(unicode_value='fantasy', tag='fantasy')
FontFamily.monospace = FontFamily._CF_enumeration.addEnumeration(unicode_value='monospace', tag='monospace')
FontFamily._InitializeFacetMap(FontFamily._CF_enumeration)
Namespace.addCategoryObject('typeBinding', 'FontFamily', FontFamily)
_module_typeBindings.FontFamily = FontFamily

# Atomic simple type: {http://www.openmicroscopy.org/Schemas/OME/2016-06}PixelType
class PixelType (pyxb.binding.datatypes.string, pyxb.binding.basis.enumeration_mixin):

    """
        The number size/kind used to represent a pixel
      """

    _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'PixelType')
    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1686, 2)
    _Documentation = '\n        The number size/kind used to represent a pixel\n      '
PixelType._CF_enumeration = pyxb.binding.facets.CF_enumeration(value_datatype=PixelType, enum_prefix=None)
PixelType.int8 = PixelType._CF_enumeration.addEnumeration(unicode_value='int8', tag='int8')
PixelType.int16 = PixelType._CF_enumeration.addEnumeration(unicode_value='int16', tag='int16')
PixelType.int32 = PixelType._CF_enumeration.addEnumeration(unicode_value='int32', tag='int32')
PixelType.uint8 = PixelType._CF_enumeration.addEnumeration(unicode_value='uint8', tag='uint8')
PixelType.uint16 = PixelType._CF_enumeration.addEnumeration(unicode_value='uint16', tag='uint16')
PixelType.uint32 = PixelType._CF_enumeration.addEnumeration(unicode_value='uint32', tag='uint32')
PixelType.float = PixelType._CF_enumeration.addEnumeration(unicode_value='float', tag='float')
PixelType.double = PixelType._CF_enumeration.addEnumeration(unicode_value='double', tag='double')
PixelType.complex = PixelType._CF_enumeration.addEnumeration(unicode_value='complex', tag='complex')
PixelType.double_complex = PixelType._CF_enumeration.addEnumeration(unicode_value='double-complex', tag='double_complex')
PixelType.bit = PixelType._CF_enumeration.addEnumeration(unicode_value='bit', tag='bit')
PixelType._InitializeFacetMap(PixelType._CF_enumeration)
Namespace.addCategoryObject('typeBinding', 'PixelType', PixelType)
_module_typeBindings.PixelType = PixelType

# Atomic simple type: {http://www.openmicroscopy.org/Schemas/OME/2016-06}Color
class Color (pyxb.binding.datatypes.int):

    """
        A simple type that identifies itself as a Color, the value is an integer between -2,147,483,648 and 2,147,483,647 (inclusive).
        The value is a signed 32 bit encoding of RGBA so "-1" is #FFFFFFFF or solid white.
        NOTE: Prior to the 2012-06 schema the default values were incorrect and produced a transparent red not solid white.
      """

    _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'Color')
    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1761, 2)
    _Documentation = '\n        A simple type that identifies itself as a Color, the value is an integer between -2,147,483,648 and 2,147,483,647 (inclusive).\n        The value is a signed 32 bit encoding of RGBA so "-1" is #FFFFFFFF or solid white.\n        NOTE: Prior to the 2012-06 schema the default values were incorrect and produced a transparent red not solid white.\n      '
Color._InitializeFacetMap()
Namespace.addCategoryObject('typeBinding', 'Color', Color)
_module_typeBindings.Color = Color

# Atomic simple type: {http://www.openmicroscopy.org/Schemas/OME/2016-06}UnitsLength
class UnitsLength (pyxb.binding.datatypes.string, pyxb.binding.basis.enumeration_mixin):

    """
        The units used to represent a length
      """

    _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'UnitsLength')
    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1773, 2)
    _Documentation = '\n        The units used to represent a length\n      '
UnitsLength._CF_enumeration = pyxb.binding.facets.CF_enumeration(value_datatype=UnitsLength, enum_prefix=None)
UnitsLength.Ym = UnitsLength._CF_enumeration.addEnumeration(unicode_value='Ym', tag='Ym')
UnitsLength.Zm = UnitsLength._CF_enumeration.addEnumeration(unicode_value='Zm', tag='Zm')
UnitsLength.Em = UnitsLength._CF_enumeration.addEnumeration(unicode_value='Em', tag='Em')
UnitsLength.Pm = UnitsLength._CF_enumeration.addEnumeration(unicode_value='Pm', tag='Pm')
UnitsLength.Tm = UnitsLength._CF_enumeration.addEnumeration(unicode_value='Tm', tag='Tm')
UnitsLength.Gm = UnitsLength._CF_enumeration.addEnumeration(unicode_value='Gm', tag='Gm')
UnitsLength.Mm = UnitsLength._CF_enumeration.addEnumeration(unicode_value='Mm', tag='Mm')
UnitsLength.km = UnitsLength._CF_enumeration.addEnumeration(unicode_value='km', tag='km')
UnitsLength.hm = UnitsLength._CF_enumeration.addEnumeration(unicode_value='hm', tag='hm')
UnitsLength.dam = UnitsLength._CF_enumeration.addEnumeration(unicode_value='dam', tag='dam')
UnitsLength.m = UnitsLength._CF_enumeration.addEnumeration(unicode_value='m', tag='m')
UnitsLength.dm = UnitsLength._CF_enumeration.addEnumeration(unicode_value='dm', tag='dm')
UnitsLength.cm = UnitsLength._CF_enumeration.addEnumeration(unicode_value='cm', tag='cm')
UnitsLength.mm = UnitsLength._CF_enumeration.addEnumeration(unicode_value='mm', tag='mm')
UnitsLength.m_ = UnitsLength._CF_enumeration.addEnumeration(unicode_value='\xb5m', tag='m_')
UnitsLength.nm = UnitsLength._CF_enumeration.addEnumeration(unicode_value='nm', tag='nm')
UnitsLength.pm = UnitsLength._CF_enumeration.addEnumeration(unicode_value='pm', tag='pm')
UnitsLength.fm = UnitsLength._CF_enumeration.addEnumeration(unicode_value='fm', tag='fm')
UnitsLength.am = UnitsLength._CF_enumeration.addEnumeration(unicode_value='am', tag='am')
UnitsLength.zm = UnitsLength._CF_enumeration.addEnumeration(unicode_value='zm', tag='zm')
UnitsLength.ym = UnitsLength._CF_enumeration.addEnumeration(unicode_value='ym', tag='ym')
UnitsLength.emptyString = UnitsLength._CF_enumeration.addEnumeration(unicode_value='\xc5', tag='emptyString')
UnitsLength.thou = UnitsLength._CF_enumeration.addEnumeration(unicode_value='thou', tag='thou')
UnitsLength.li = UnitsLength._CF_enumeration.addEnumeration(unicode_value='li', tag='li')
UnitsLength.in_ = UnitsLength._CF_enumeration.addEnumeration(unicode_value='in', tag='in_')
UnitsLength.ft = UnitsLength._CF_enumeration.addEnumeration(unicode_value='ft', tag='ft')
UnitsLength.yd = UnitsLength._CF_enumeration.addEnumeration(unicode_value='yd', tag='yd')
UnitsLength.mi = UnitsLength._CF_enumeration.addEnumeration(unicode_value='mi', tag='mi')
UnitsLength.ua = UnitsLength._CF_enumeration.addEnumeration(unicode_value='ua', tag='ua')
UnitsLength.ly = UnitsLength._CF_enumeration.addEnumeration(unicode_value='ly', tag='ly')
UnitsLength.pc = UnitsLength._CF_enumeration.addEnumeration(unicode_value='pc', tag='pc')
UnitsLength.pt = UnitsLength._CF_enumeration.addEnumeration(unicode_value='pt', tag='pt')
UnitsLength.pixel = UnitsLength._CF_enumeration.addEnumeration(unicode_value='pixel', tag='pixel')
UnitsLength.reference_frame = UnitsLength._CF_enumeration.addEnumeration(unicode_value='reference frame', tag='reference_frame')
UnitsLength._InitializeFacetMap(UnitsLength._CF_enumeration)
Namespace.addCategoryObject('typeBinding', 'UnitsLength', UnitsLength)
_module_typeBindings.UnitsLength = UnitsLength

# Atomic simple type: {http://www.openmicroscopy.org/Schemas/OME/2016-06}UnitsTime
class UnitsTime (pyxb.binding.datatypes.string, pyxb.binding.basis.enumeration_mixin):

    """
        The units used to represent a time interval
      """

    _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'UnitsTime')
    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1822, 2)
    _Documentation = '\n        The units used to represent a time interval\n      '
UnitsTime._CF_enumeration = pyxb.binding.facets.CF_enumeration(value_datatype=UnitsTime, enum_prefix=None)
UnitsTime.Ys = UnitsTime._CF_enumeration.addEnumeration(unicode_value='Ys', tag='Ys')
UnitsTime.Zs = UnitsTime._CF_enumeration.addEnumeration(unicode_value='Zs', tag='Zs')
UnitsTime.Es = UnitsTime._CF_enumeration.addEnumeration(unicode_value='Es', tag='Es')
UnitsTime.Ps = UnitsTime._CF_enumeration.addEnumeration(unicode_value='Ps', tag='Ps')
UnitsTime.Ts = UnitsTime._CF_enumeration.addEnumeration(unicode_value='Ts', tag='Ts')
UnitsTime.Gs = UnitsTime._CF_enumeration.addEnumeration(unicode_value='Gs', tag='Gs')
UnitsTime.Ms = UnitsTime._CF_enumeration.addEnumeration(unicode_value='Ms', tag='Ms')
UnitsTime.ks = UnitsTime._CF_enumeration.addEnumeration(unicode_value='ks', tag='ks')
UnitsTime.hs = UnitsTime._CF_enumeration.addEnumeration(unicode_value='hs', tag='hs')
UnitsTime.das = UnitsTime._CF_enumeration.addEnumeration(unicode_value='das', tag='das')
UnitsTime.s = UnitsTime._CF_enumeration.addEnumeration(unicode_value='s', tag='s')
UnitsTime.ds = UnitsTime._CF_enumeration.addEnumeration(unicode_value='ds', tag='ds')
UnitsTime.cs = UnitsTime._CF_enumeration.addEnumeration(unicode_value='cs', tag='cs')
UnitsTime.ms = UnitsTime._CF_enumeration.addEnumeration(unicode_value='ms', tag='ms')
UnitsTime.s_ = UnitsTime._CF_enumeration.addEnumeration(unicode_value='\xb5s', tag='s_')
UnitsTime.ns = UnitsTime._CF_enumeration.addEnumeration(unicode_value='ns', tag='ns')
UnitsTime.ps = UnitsTime._CF_enumeration.addEnumeration(unicode_value='ps', tag='ps')
UnitsTime.fs = UnitsTime._CF_enumeration.addEnumeration(unicode_value='fs', tag='fs')
UnitsTime.as_ = UnitsTime._CF_enumeration.addEnumeration(unicode_value='as', tag='as_')
UnitsTime.zs = UnitsTime._CF_enumeration.addEnumeration(unicode_value='zs', tag='zs')
UnitsTime.ys = UnitsTime._CF_enumeration.addEnumeration(unicode_value='ys', tag='ys')
UnitsTime.min = UnitsTime._CF_enumeration.addEnumeration(unicode_value='min', tag='min')
UnitsTime.h = UnitsTime._CF_enumeration.addEnumeration(unicode_value='h', tag='h')
UnitsTime.d = UnitsTime._CF_enumeration.addEnumeration(unicode_value='d', tag='d')
UnitsTime._InitializeFacetMap(UnitsTime._CF_enumeration)
Namespace.addCategoryObject('typeBinding', 'UnitsTime', UnitsTime)
_module_typeBindings.UnitsTime = UnitsTime

# Atomic simple type: {http://www.openmicroscopy.org/Schemas/OME/2016-06}UnitsPressure
class UnitsPressure (pyxb.binding.datatypes.string, pyxb.binding.basis.enumeration_mixin):

    """
        The units used to represent a pressure
      """

    _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'UnitsPressure')
    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1857, 2)
    _Documentation = '\n        The units used to represent a pressure\n      '
UnitsPressure._CF_enumeration = pyxb.binding.facets.CF_enumeration(value_datatype=UnitsPressure, enum_prefix=None)
UnitsPressure.YPa = UnitsPressure._CF_enumeration.addEnumeration(unicode_value='YPa', tag='YPa')
UnitsPressure.ZPa = UnitsPressure._CF_enumeration.addEnumeration(unicode_value='ZPa', tag='ZPa')
UnitsPressure.EPa = UnitsPressure._CF_enumeration.addEnumeration(unicode_value='EPa', tag='EPa')
UnitsPressure.PPa = UnitsPressure._CF_enumeration.addEnumeration(unicode_value='PPa', tag='PPa')
UnitsPressure.TPa = UnitsPressure._CF_enumeration.addEnumeration(unicode_value='TPa', tag='TPa')
UnitsPressure.GPa = UnitsPressure._CF_enumeration.addEnumeration(unicode_value='GPa', tag='GPa')
UnitsPressure.MPa = UnitsPressure._CF_enumeration.addEnumeration(unicode_value='MPa', tag='MPa')
UnitsPressure.kPa = UnitsPressure._CF_enumeration.addEnumeration(unicode_value='kPa', tag='kPa')
UnitsPressure.hPa = UnitsPressure._CF_enumeration.addEnumeration(unicode_value='hPa', tag='hPa')
UnitsPressure.daPa = UnitsPressure._CF_enumeration.addEnumeration(unicode_value='daPa', tag='daPa')
UnitsPressure.Pa = UnitsPressure._CF_enumeration.addEnumeration(unicode_value='Pa', tag='Pa')
UnitsPressure.dPa = UnitsPressure._CF_enumeration.addEnumeration(unicode_value='dPa', tag='dPa')
UnitsPressure.cPa = UnitsPressure._CF_enumeration.addEnumeration(unicode_value='cPa', tag='cPa')
UnitsPressure.mPa = UnitsPressure._CF_enumeration.addEnumeration(unicode_value='mPa', tag='mPa')
UnitsPressure.Pa_ = UnitsPressure._CF_enumeration.addEnumeration(unicode_value='\xb5Pa', tag='Pa_')
UnitsPressure.nPa = UnitsPressure._CF_enumeration.addEnumeration(unicode_value='nPa', tag='nPa')
UnitsPressure.pPa = UnitsPressure._CF_enumeration.addEnumeration(unicode_value='pPa', tag='pPa')
UnitsPressure.fPa = UnitsPressure._CF_enumeration.addEnumeration(unicode_value='fPa', tag='fPa')
UnitsPressure.aPa = UnitsPressure._CF_enumeration.addEnumeration(unicode_value='aPa', tag='aPa')
UnitsPressure.zPa = UnitsPressure._CF_enumeration.addEnumeration(unicode_value='zPa', tag='zPa')
UnitsPressure.yPa = UnitsPressure._CF_enumeration.addEnumeration(unicode_value='yPa', tag='yPa')
UnitsPressure.bar = UnitsPressure._CF_enumeration.addEnumeration(unicode_value='bar', tag='bar')
UnitsPressure.Mbar = UnitsPressure._CF_enumeration.addEnumeration(unicode_value='Mbar', tag='Mbar')
UnitsPressure.kbar = UnitsPressure._CF_enumeration.addEnumeration(unicode_value='kbar', tag='kbar')
UnitsPressure.dbar = UnitsPressure._CF_enumeration.addEnumeration(unicode_value='dbar', tag='dbar')
UnitsPressure.cbar = UnitsPressure._CF_enumeration.addEnumeration(unicode_value='cbar', tag='cbar')
UnitsPressure.mbar = UnitsPressure._CF_enumeration.addEnumeration(unicode_value='mbar', tag='mbar')
UnitsPressure.atm = UnitsPressure._CF_enumeration.addEnumeration(unicode_value='atm', tag='atm')
UnitsPressure.psi = UnitsPressure._CF_enumeration.addEnumeration(unicode_value='psi', tag='psi')
UnitsPressure.Torr = UnitsPressure._CF_enumeration.addEnumeration(unicode_value='Torr', tag='Torr')
UnitsPressure.mTorr = UnitsPressure._CF_enumeration.addEnumeration(unicode_value='mTorr', tag='mTorr')
UnitsPressure.mm_Hg = UnitsPressure._CF_enumeration.addEnumeration(unicode_value='mm Hg', tag='mm_Hg')
UnitsPressure._InitializeFacetMap(UnitsPressure._CF_enumeration)
Namespace.addCategoryObject('typeBinding', 'UnitsPressure', UnitsPressure)
_module_typeBindings.UnitsPressure = UnitsPressure

# Atomic simple type: {http://www.openmicroscopy.org/Schemas/OME/2016-06}UnitsAngle
class UnitsAngle (pyxb.binding.datatypes.string, pyxb.binding.basis.enumeration_mixin):

    """
        The units used to represent an angle
      """

    _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'UnitsAngle')
    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1903, 2)
    _Documentation = '\n        The units used to represent an angle\n      '
UnitsAngle._CF_enumeration = pyxb.binding.facets.CF_enumeration(value_datatype=UnitsAngle, enum_prefix=None)
UnitsAngle.deg = UnitsAngle._CF_enumeration.addEnumeration(unicode_value='deg', tag='deg')
UnitsAngle.rad = UnitsAngle._CF_enumeration.addEnumeration(unicode_value='rad', tag='rad')
UnitsAngle.gon = UnitsAngle._CF_enumeration.addEnumeration(unicode_value='gon', tag='gon')
UnitsAngle._InitializeFacetMap(UnitsAngle._CF_enumeration)
Namespace.addCategoryObject('typeBinding', 'UnitsAngle', UnitsAngle)
_module_typeBindings.UnitsAngle = UnitsAngle

# Atomic simple type: {http://www.openmicroscopy.org/Schemas/OME/2016-06}UnitsTemperature
class UnitsTemperature (pyxb.binding.datatypes.string, pyxb.binding.basis.enumeration_mixin):

    """
        The units used to represent a temperature
      """

    _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'UnitsTemperature')
    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1916, 2)
    _Documentation = '\n        The units used to represent a temperature\n      '
UnitsTemperature._CF_enumeration = pyxb.binding.facets.CF_enumeration(value_datatype=UnitsTemperature, enum_prefix=None)
UnitsTemperature.C = UnitsTemperature._CF_enumeration.addEnumeration(unicode_value='\xb0C', tag='C')
UnitsTemperature.F = UnitsTemperature._CF_enumeration.addEnumeration(unicode_value='\xb0F', tag='F')
UnitsTemperature.K = UnitsTemperature._CF_enumeration.addEnumeration(unicode_value='K', tag='K')
UnitsTemperature.R = UnitsTemperature._CF_enumeration.addEnumeration(unicode_value='\xb0R', tag='R')
UnitsTemperature._InitializeFacetMap(UnitsTemperature._CF_enumeration)
Namespace.addCategoryObject('typeBinding', 'UnitsTemperature', UnitsTemperature)
_module_typeBindings.UnitsTemperature = UnitsTemperature

# Atomic simple type: {http://www.openmicroscopy.org/Schemas/OME/2016-06}UnitsElectricPotential
class UnitsElectricPotential (pyxb.binding.datatypes.string, pyxb.binding.basis.enumeration_mixin):

    """
        The units used to represent an electric potential
      """

    _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'UnitsElectricPotential')
    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1930, 2)
    _Documentation = '\n        The units used to represent an electric potential\n      '
UnitsElectricPotential._CF_enumeration = pyxb.binding.facets.CF_enumeration(value_datatype=UnitsElectricPotential, enum_prefix=None)
UnitsElectricPotential.YV = UnitsElectricPotential._CF_enumeration.addEnumeration(unicode_value='YV', tag='YV')
UnitsElectricPotential.ZV = UnitsElectricPotential._CF_enumeration.addEnumeration(unicode_value='ZV', tag='ZV')
UnitsElectricPotential.EV = UnitsElectricPotential._CF_enumeration.addEnumeration(unicode_value='EV', tag='EV')
UnitsElectricPotential.PV = UnitsElectricPotential._CF_enumeration.addEnumeration(unicode_value='PV', tag='PV')
UnitsElectricPotential.TV = UnitsElectricPotential._CF_enumeration.addEnumeration(unicode_value='TV', tag='TV')
UnitsElectricPotential.GV = UnitsElectricPotential._CF_enumeration.addEnumeration(unicode_value='GV', tag='GV')
UnitsElectricPotential.MV = UnitsElectricPotential._CF_enumeration.addEnumeration(unicode_value='MV', tag='MV')
UnitsElectricPotential.kV = UnitsElectricPotential._CF_enumeration.addEnumeration(unicode_value='kV', tag='kV')
UnitsElectricPotential.hV = UnitsElectricPotential._CF_enumeration.addEnumeration(unicode_value='hV', tag='hV')
UnitsElectricPotential.daV = UnitsElectricPotential._CF_enumeration.addEnumeration(unicode_value='daV', tag='daV')
UnitsElectricPotential.V = UnitsElectricPotential._CF_enumeration.addEnumeration(unicode_value='V', tag='V')
UnitsElectricPotential.dV = UnitsElectricPotential._CF_enumeration.addEnumeration(unicode_value='dV', tag='dV')
UnitsElectricPotential.cV = UnitsElectricPotential._CF_enumeration.addEnumeration(unicode_value='cV', tag='cV')
UnitsElectricPotential.mV = UnitsElectricPotential._CF_enumeration.addEnumeration(unicode_value='mV', tag='mV')
UnitsElectricPotential.V_ = UnitsElectricPotential._CF_enumeration.addEnumeration(unicode_value='\xb5V', tag='V_')
UnitsElectricPotential.nV = UnitsElectricPotential._CF_enumeration.addEnumeration(unicode_value='nV', tag='nV')
UnitsElectricPotential.pV = UnitsElectricPotential._CF_enumeration.addEnumeration(unicode_value='pV', tag='pV')
UnitsElectricPotential.fV = UnitsElectricPotential._CF_enumeration.addEnumeration(unicode_value='fV', tag='fV')
UnitsElectricPotential.aV = UnitsElectricPotential._CF_enumeration.addEnumeration(unicode_value='aV', tag='aV')
UnitsElectricPotential.zV = UnitsElectricPotential._CF_enumeration.addEnumeration(unicode_value='zV', tag='zV')
UnitsElectricPotential.yV = UnitsElectricPotential._CF_enumeration.addEnumeration(unicode_value='yV', tag='yV')
UnitsElectricPotential._InitializeFacetMap(UnitsElectricPotential._CF_enumeration)
Namespace.addCategoryObject('typeBinding', 'UnitsElectricPotential', UnitsElectricPotential)
_module_typeBindings.UnitsElectricPotential = UnitsElectricPotential

# Atomic simple type: {http://www.openmicroscopy.org/Schemas/OME/2016-06}UnitsPower
class UnitsPower (pyxb.binding.datatypes.string, pyxb.binding.basis.enumeration_mixin):

    """
        The units used to represent power
      """

    _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'UnitsPower')
    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1961, 2)
    _Documentation = '\n        The units used to represent power\n      '
UnitsPower._CF_enumeration = pyxb.binding.facets.CF_enumeration(value_datatype=UnitsPower, enum_prefix=None)
UnitsPower.YW = UnitsPower._CF_enumeration.addEnumeration(unicode_value='YW', tag='YW')
UnitsPower.ZW = UnitsPower._CF_enumeration.addEnumeration(unicode_value='ZW', tag='ZW')
UnitsPower.EW = UnitsPower._CF_enumeration.addEnumeration(unicode_value='EW', tag='EW')
UnitsPower.PW = UnitsPower._CF_enumeration.addEnumeration(unicode_value='PW', tag='PW')
UnitsPower.TW = UnitsPower._CF_enumeration.addEnumeration(unicode_value='TW', tag='TW')
UnitsPower.GW = UnitsPower._CF_enumeration.addEnumeration(unicode_value='GW', tag='GW')
UnitsPower.MW = UnitsPower._CF_enumeration.addEnumeration(unicode_value='MW', tag='MW')
UnitsPower.kW = UnitsPower._CF_enumeration.addEnumeration(unicode_value='kW', tag='kW')
UnitsPower.hW = UnitsPower._CF_enumeration.addEnumeration(unicode_value='hW', tag='hW')
UnitsPower.daW = UnitsPower._CF_enumeration.addEnumeration(unicode_value='daW', tag='daW')
UnitsPower.W = UnitsPower._CF_enumeration.addEnumeration(unicode_value='W', tag='W')
UnitsPower.dW = UnitsPower._CF_enumeration.addEnumeration(unicode_value='dW', tag='dW')
UnitsPower.cW = UnitsPower._CF_enumeration.addEnumeration(unicode_value='cW', tag='cW')
UnitsPower.mW = UnitsPower._CF_enumeration.addEnumeration(unicode_value='mW', tag='mW')
UnitsPower.W_ = UnitsPower._CF_enumeration.addEnumeration(unicode_value='\xb5W', tag='W_')
UnitsPower.nW = UnitsPower._CF_enumeration.addEnumeration(unicode_value='nW', tag='nW')
UnitsPower.pW = UnitsPower._CF_enumeration.addEnumeration(unicode_value='pW', tag='pW')
UnitsPower.fW = UnitsPower._CF_enumeration.addEnumeration(unicode_value='fW', tag='fW')
UnitsPower.aW = UnitsPower._CF_enumeration.addEnumeration(unicode_value='aW', tag='aW')
UnitsPower.zW = UnitsPower._CF_enumeration.addEnumeration(unicode_value='zW', tag='zW')
UnitsPower.yW = UnitsPower._CF_enumeration.addEnumeration(unicode_value='yW', tag='yW')
UnitsPower._InitializeFacetMap(UnitsPower._CF_enumeration)
Namespace.addCategoryObject('typeBinding', 'UnitsPower', UnitsPower)
_module_typeBindings.UnitsPower = UnitsPower

# Atomic simple type: {http://www.openmicroscopy.org/Schemas/OME/2016-06}UnitsFrequency
class UnitsFrequency (pyxb.binding.datatypes.string, pyxb.binding.basis.enumeration_mixin):

    """
        The units used to represent frequency
      """

    _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'UnitsFrequency')
    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1992, 2)
    _Documentation = '\n        The units used to represent frequency\n      '
UnitsFrequency._CF_enumeration = pyxb.binding.facets.CF_enumeration(value_datatype=UnitsFrequency, enum_prefix=None)
UnitsFrequency.YHz = UnitsFrequency._CF_enumeration.addEnumeration(unicode_value='YHz', tag='YHz')
UnitsFrequency.ZHz = UnitsFrequency._CF_enumeration.addEnumeration(unicode_value='ZHz', tag='ZHz')
UnitsFrequency.EHz = UnitsFrequency._CF_enumeration.addEnumeration(unicode_value='EHz', tag='EHz')
UnitsFrequency.PHz = UnitsFrequency._CF_enumeration.addEnumeration(unicode_value='PHz', tag='PHz')
UnitsFrequency.THz = UnitsFrequency._CF_enumeration.addEnumeration(unicode_value='THz', tag='THz')
UnitsFrequency.GHz = UnitsFrequency._CF_enumeration.addEnumeration(unicode_value='GHz', tag='GHz')
UnitsFrequency.MHz = UnitsFrequency._CF_enumeration.addEnumeration(unicode_value='MHz', tag='MHz')
UnitsFrequency.kHz = UnitsFrequency._CF_enumeration.addEnumeration(unicode_value='kHz', tag='kHz')
UnitsFrequency.hHz = UnitsFrequency._CF_enumeration.addEnumeration(unicode_value='hHz', tag='hHz')
UnitsFrequency.daHz = UnitsFrequency._CF_enumeration.addEnumeration(unicode_value='daHz', tag='daHz')
UnitsFrequency.Hz = UnitsFrequency._CF_enumeration.addEnumeration(unicode_value='Hz', tag='Hz')
UnitsFrequency.dHz = UnitsFrequency._CF_enumeration.addEnumeration(unicode_value='dHz', tag='dHz')
UnitsFrequency.cHz = UnitsFrequency._CF_enumeration.addEnumeration(unicode_value='cHz', tag='cHz')
UnitsFrequency.mHz = UnitsFrequency._CF_enumeration.addEnumeration(unicode_value='mHz', tag='mHz')
UnitsFrequency.Hz_ = UnitsFrequency._CF_enumeration.addEnumeration(unicode_value='\xb5Hz', tag='Hz_')
UnitsFrequency.nHz = UnitsFrequency._CF_enumeration.addEnumeration(unicode_value='nHz', tag='nHz')
UnitsFrequency.pHz = UnitsFrequency._CF_enumeration.addEnumeration(unicode_value='pHz', tag='pHz')
UnitsFrequency.fHz = UnitsFrequency._CF_enumeration.addEnumeration(unicode_value='fHz', tag='fHz')
UnitsFrequency.aHz = UnitsFrequency._CF_enumeration.addEnumeration(unicode_value='aHz', tag='aHz')
UnitsFrequency.zHz = UnitsFrequency._CF_enumeration.addEnumeration(unicode_value='zHz', tag='zHz')
UnitsFrequency.yHz = UnitsFrequency._CF_enumeration.addEnumeration(unicode_value='yHz', tag='yHz')
UnitsFrequency._InitializeFacetMap(UnitsFrequency._CF_enumeration)
Namespace.addCategoryObject('typeBinding', 'UnitsFrequency', UnitsFrequency)
_module_typeBindings.UnitsFrequency = UnitsFrequency

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

    """An atomic simple type."""

    _ExpandedName = None
    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2061, 12)
    _Documentation = None
STD_ANON_14._CF_enumeration = pyxb.binding.facets.CF_enumeration(value_datatype=STD_ANON_14, enum_prefix=None)
STD_ANON_14.UV = STD_ANON_14._CF_enumeration.addEnumeration(unicode_value='UV', tag='UV')
STD_ANON_14.PlanApo = STD_ANON_14._CF_enumeration.addEnumeration(unicode_value='PlanApo', tag='PlanApo')
STD_ANON_14.PlanFluor = STD_ANON_14._CF_enumeration.addEnumeration(unicode_value='PlanFluor', tag='PlanFluor')
STD_ANON_14.SuperFluor = STD_ANON_14._CF_enumeration.addEnumeration(unicode_value='SuperFluor', tag='SuperFluor')
STD_ANON_14.VioletCorrected = STD_ANON_14._CF_enumeration.addEnumeration(unicode_value='VioletCorrected', tag='VioletCorrected')
STD_ANON_14.Achro = STD_ANON_14._CF_enumeration.addEnumeration(unicode_value='Achro', tag='Achro')
STD_ANON_14.Achromat = STD_ANON_14._CF_enumeration.addEnumeration(unicode_value='Achromat', tag='Achromat')
STD_ANON_14.Fluor = STD_ANON_14._CF_enumeration.addEnumeration(unicode_value='Fluor', tag='Fluor')
STD_ANON_14.Fl = STD_ANON_14._CF_enumeration.addEnumeration(unicode_value='Fl', tag='Fl')
STD_ANON_14.Fluar = STD_ANON_14._CF_enumeration.addEnumeration(unicode_value='Fluar', tag='Fluar')
STD_ANON_14.Neofluar = STD_ANON_14._CF_enumeration.addEnumeration(unicode_value='Neofluar', tag='Neofluar')
STD_ANON_14.Fluotar = STD_ANON_14._CF_enumeration.addEnumeration(unicode_value='Fluotar', tag='Fluotar')
STD_ANON_14.Apo = STD_ANON_14._CF_enumeration.addEnumeration(unicode_value='Apo', tag='Apo')
STD_ANON_14.PlanNeofluar = STD_ANON_14._CF_enumeration.addEnumeration(unicode_value='PlanNeofluar', tag='PlanNeofluar')
STD_ANON_14.Other = STD_ANON_14._CF_enumeration.addEnumeration(unicode_value='Other', tag='Other')
STD_ANON_14._InitializeFacetMap(STD_ANON_14._CF_enumeration)
_module_typeBindings.STD_ANON_14 = STD_ANON_14

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

    """An atomic simple type."""

    _ExpandedName = None
    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2085, 12)
    _Documentation = None
STD_ANON_15._CF_enumeration = pyxb.binding.facets.CF_enumeration(value_datatype=STD_ANON_15, enum_prefix=None)
STD_ANON_15.Oil = STD_ANON_15._CF_enumeration.addEnumeration(unicode_value='Oil', tag='Oil')
STD_ANON_15.Water = STD_ANON_15._CF_enumeration.addEnumeration(unicode_value='Water', tag='Water')
STD_ANON_15.WaterDipping = STD_ANON_15._CF_enumeration.addEnumeration(unicode_value='WaterDipping', tag='WaterDipping')
STD_ANON_15.Air = STD_ANON_15._CF_enumeration.addEnumeration(unicode_value='Air', tag='Air')
STD_ANON_15.Multi = STD_ANON_15._CF_enumeration.addEnumeration(unicode_value='Multi', tag='Multi')
STD_ANON_15.Glycerol = STD_ANON_15._CF_enumeration.addEnumeration(unicode_value='Glycerol', tag='Glycerol')
STD_ANON_15.Other = STD_ANON_15._CF_enumeration.addEnumeration(unicode_value='Other', tag='Other')
STD_ANON_15._InitializeFacetMap(STD_ANON_15._CF_enumeration)
_module_typeBindings.STD_ANON_15 = STD_ANON_15

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

    """An atomic simple type."""

    _ExpandedName = None
    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2217, 12)
    _Documentation = None
STD_ANON_16._CF_enumeration = pyxb.binding.facets.CF_enumeration(value_datatype=STD_ANON_16, enum_prefix=None)
STD_ANON_16.CCD = STD_ANON_16._CF_enumeration.addEnumeration(unicode_value='CCD', tag='CCD')
STD_ANON_16.IntensifiedCCD = STD_ANON_16._CF_enumeration.addEnumeration(unicode_value='IntensifiedCCD', tag='IntensifiedCCD')
STD_ANON_16.AnalogVideo = STD_ANON_16._CF_enumeration.addEnumeration(unicode_value='AnalogVideo', tag='AnalogVideo')
STD_ANON_16.PMT = STD_ANON_16._CF_enumeration.addEnumeration(unicode_value='PMT', tag='PMT')
STD_ANON_16.Photodiode = STD_ANON_16._CF_enumeration.addEnumeration(unicode_value='Photodiode', tag='Photodiode')
STD_ANON_16.Spectroscopy = STD_ANON_16._CF_enumeration.addEnumeration(unicode_value='Spectroscopy', tag='Spectroscopy')
STD_ANON_16.LifetimeImaging = STD_ANON_16._CF_enumeration.addEnumeration(unicode_value='LifetimeImaging', tag='LifetimeImaging')
STD_ANON_16.CorrelationSpectroscopy = STD_ANON_16._CF_enumeration.addEnumeration(unicode_value='CorrelationSpectroscopy', tag='CorrelationSpectroscopy')
STD_ANON_16.FTIR = STD_ANON_16._CF_enumeration.addEnumeration(unicode_value='FTIR', tag='FTIR')
STD_ANON_16.EMCCD = STD_ANON_16._CF_enumeration.addEnumeration(unicode_value='EMCCD', tag='EMCCD')
STD_ANON_16.APD = STD_ANON_16._CF_enumeration.addEnumeration(unicode_value='APD', tag='APD')
STD_ANON_16.CMOS = STD_ANON_16._CF_enumeration.addEnumeration(unicode_value='CMOS', tag='CMOS')
STD_ANON_16.EBCCD = STD_ANON_16._CF_enumeration.addEnumeration(unicode_value='EBCCD', tag='EBCCD')
STD_ANON_16.Other = STD_ANON_16._CF_enumeration.addEnumeration(unicode_value='Other', tag='Other')
STD_ANON_16._InitializeFacetMap(STD_ANON_16._CF_enumeration)
_module_typeBindings.STD_ANON_16 = STD_ANON_16

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

    """An atomic simple type."""

    _ExpandedName = None
    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2300, 12)
    _Documentation = None
STD_ANON_17._CF_enumeration = pyxb.binding.facets.CF_enumeration(value_datatype=STD_ANON_17, enum_prefix=None)
STD_ANON_17.Dichroic = STD_ANON_17._CF_enumeration.addEnumeration(unicode_value='Dichroic', tag='Dichroic')
STD_ANON_17.LongPass = STD_ANON_17._CF_enumeration.addEnumeration(unicode_value='LongPass', tag='LongPass')
STD_ANON_17.ShortPass = STD_ANON_17._CF_enumeration.addEnumeration(unicode_value='ShortPass', tag='ShortPass')
STD_ANON_17.BandPass = STD_ANON_17._CF_enumeration.addEnumeration(unicode_value='BandPass', tag='BandPass')
STD_ANON_17.MultiPass = STD_ANON_17._CF_enumeration.addEnumeration(unicode_value='MultiPass', tag='MultiPass')
STD_ANON_17.NeutralDensity = STD_ANON_17._CF_enumeration.addEnumeration(unicode_value='NeutralDensity', tag='NeutralDensity')
STD_ANON_17.Tuneable = STD_ANON_17._CF_enumeration.addEnumeration(unicode_value='Tuneable', tag='Tuneable')
STD_ANON_17.Other = STD_ANON_17._CF_enumeration.addEnumeration(unicode_value='Other', tag='Other')
STD_ANON_17._InitializeFacetMap(STD_ANON_17._CF_enumeration)
_module_typeBindings.STD_ANON_17 = STD_ANON_17

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

    """An atomic simple type."""

    _ExpandedName = None
    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2523, 12)
    _Documentation = None
STD_ANON_18._CF_enumeration = pyxb.binding.facets.CF_enumeration(value_datatype=STD_ANON_18, enum_prefix=None)
STD_ANON_18.Excimer = STD_ANON_18._CF_enumeration.addEnumeration(unicode_value='Excimer', tag='Excimer')
STD_ANON_18.Gas = STD_ANON_18._CF_enumeration.addEnumeration(unicode_value='Gas', tag='Gas')
STD_ANON_18.MetalVapor = STD_ANON_18._CF_enumeration.addEnumeration(unicode_value='MetalVapor', tag='MetalVapor')
STD_ANON_18.SolidState = STD_ANON_18._CF_enumeration.addEnumeration(unicode_value='SolidState', tag='SolidState')
STD_ANON_18.Dye = STD_ANON_18._CF_enumeration.addEnumeration(unicode_value='Dye', tag='Dye')
STD_ANON_18.Semiconductor = STD_ANON_18._CF_enumeration.addEnumeration(unicode_value='Semiconductor', tag='Semiconductor')
STD_ANON_18.FreeElectron = STD_ANON_18._CF_enumeration.addEnumeration(unicode_value='FreeElectron', tag='FreeElectron')
STD_ANON_18.Other = STD_ANON_18._CF_enumeration.addEnumeration(unicode_value='Other', tag='Other')
STD_ANON_18._InitializeFacetMap(STD_ANON_18._CF_enumeration)
_module_typeBindings.STD_ANON_18 = STD_ANON_18

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

    """An atomic simple type."""

    _ExpandedName = None
    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2543, 12)
    _Documentation = None
STD_ANON_19._CF_enumeration = pyxb.binding.facets.CF_enumeration(value_datatype=STD_ANON_19, enum_prefix=None)
STD_ANON_19.Cu = STD_ANON_19._CF_enumeration.addEnumeration(unicode_value='Cu', tag='Cu')
STD_ANON_19.Ag = STD_ANON_19._CF_enumeration.addEnumeration(unicode_value='Ag', tag='Ag')
STD_ANON_19.ArFl = STD_ANON_19._CF_enumeration.addEnumeration(unicode_value='ArFl', tag='ArFl')
STD_ANON_19.ArCl = STD_ANON_19._CF_enumeration.addEnumeration(unicode_value='ArCl', tag='ArCl')
STD_ANON_19.KrFl = STD_ANON_19._CF_enumeration.addEnumeration(unicode_value='KrFl', tag='KrFl')
STD_ANON_19.KrCl = STD_ANON_19._CF_enumeration.addEnumeration(unicode_value='KrCl', tag='KrCl')
STD_ANON_19.XeFl = STD_ANON_19._CF_enumeration.addEnumeration(unicode_value='XeFl', tag='XeFl')
STD_ANON_19.XeCl = STD_ANON_19._CF_enumeration.addEnumeration(unicode_value='XeCl', tag='XeCl')
STD_ANON_19.XeBr = STD_ANON_19._CF_enumeration.addEnumeration(unicode_value='XeBr', tag='XeBr')
STD_ANON_19.N = STD_ANON_19._CF_enumeration.addEnumeration(unicode_value='N', tag='N')
STD_ANON_19.Ar = STD_ANON_19._CF_enumeration.addEnumeration(unicode_value='Ar', tag='Ar')
STD_ANON_19.Kr = STD_ANON_19._CF_enumeration.addEnumeration(unicode_value='Kr', tag='Kr')
STD_ANON_19.Xe = STD_ANON_19._CF_enumeration.addEnumeration(unicode_value='Xe', tag='Xe')
STD_ANON_19.HeNe = STD_ANON_19._CF_enumeration.addEnumeration(unicode_value='HeNe', tag='HeNe')
STD_ANON_19.HeCd = STD_ANON_19._CF_enumeration.addEnumeration(unicode_value='HeCd', tag='HeCd')
STD_ANON_19.CO = STD_ANON_19._CF_enumeration.addEnumeration(unicode_value='CO', tag='CO')
STD_ANON_19.CO2 = STD_ANON_19._CF_enumeration.addEnumeration(unicode_value='CO2', tag='CO2')
STD_ANON_19.H2O = STD_ANON_19._CF_enumeration.addEnumeration(unicode_value='H2O', tag='H2O')
STD_ANON_19.HFl = STD_ANON_19._CF_enumeration.addEnumeration(unicode_value='HFl', tag='HFl')
STD_ANON_19.NdGlass = STD_ANON_19._CF_enumeration.addEnumeration(unicode_value='NdGlass', tag='NdGlass')
STD_ANON_19.NdYAG = STD_ANON_19._CF_enumeration.addEnumeration(unicode_value='NdYAG', tag='NdYAG')
STD_ANON_19.ErGlass = STD_ANON_19._CF_enumeration.addEnumeration(unicode_value='ErGlass', tag='ErGlass')
STD_ANON_19.ErYAG = STD_ANON_19._CF_enumeration.addEnumeration(unicode_value='ErYAG', tag='ErYAG')
STD_ANON_19.HoYLF = STD_ANON_19._CF_enumeration.addEnumeration(unicode_value='HoYLF', tag='HoYLF')
STD_ANON_19.HoYAG = STD_ANON_19._CF_enumeration.addEnumeration(unicode_value='HoYAG', tag='HoYAG')
STD_ANON_19.Ruby = STD_ANON_19._CF_enumeration.addEnumeration(unicode_value='Ruby', tag='Ruby')
STD_ANON_19.TiSapphire = STD_ANON_19._CF_enumeration.addEnumeration(unicode_value='TiSapphire', tag='TiSapphire')
STD_ANON_19.Alexandrite = STD_ANON_19._CF_enumeration.addEnumeration(unicode_value='Alexandrite', tag='Alexandrite')
STD_ANON_19.Rhodamine6G = STD_ANON_19._CF_enumeration.addEnumeration(unicode_value='Rhodamine6G', tag='Rhodamine6G')
STD_ANON_19.CoumarinC30 = STD_ANON_19._CF_enumeration.addEnumeration(unicode_value='CoumarinC30', tag='CoumarinC30')
STD_ANON_19.GaAs = STD_ANON_19._CF_enumeration.addEnumeration(unicode_value='GaAs', tag='GaAs')
STD_ANON_19.GaAlAs = STD_ANON_19._CF_enumeration.addEnumeration(unicode_value='GaAlAs', tag='GaAlAs')
STD_ANON_19.EMinus = STD_ANON_19._CF_enumeration.addEnumeration(unicode_value='EMinus', tag='EMinus')
STD_ANON_19.Other = STD_ANON_19._CF_enumeration.addEnumeration(unicode_value='Other', tag='Other')
STD_ANON_19._InitializeFacetMap(STD_ANON_19._CF_enumeration)
_module_typeBindings.STD_ANON_19 = STD_ANON_19

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

    """An atomic simple type."""

    _ExpandedName = None
    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2622, 12)
    _Documentation = None
STD_ANON_20._CF_enumeration = pyxb.binding.facets.CF_enumeration(value_datatype=STD_ANON_20, enum_prefix=None)
STD_ANON_20.CW = STD_ANON_20._CF_enumeration.addEnumeration(unicode_value='CW', tag='CW')
STD_ANON_20.Single = STD_ANON_20._CF_enumeration.addEnumeration(unicode_value='Single', tag='Single')
STD_ANON_20.QSwitched = STD_ANON_20._CF_enumeration.addEnumeration(unicode_value='QSwitched', tag='QSwitched')
STD_ANON_20.Repetitive = STD_ANON_20._CF_enumeration.addEnumeration(unicode_value='Repetitive', tag='Repetitive')
STD_ANON_20.ModeLocked = STD_ANON_20._CF_enumeration.addEnumeration(unicode_value='ModeLocked', tag='ModeLocked')
STD_ANON_20.Other = STD_ANON_20._CF_enumeration.addEnumeration(unicode_value='Other', tag='Other')
STD_ANON_20._InitializeFacetMap(STD_ANON_20._CF_enumeration)
_module_typeBindings.STD_ANON_20 = STD_ANON_20

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

    """An atomic simple type."""

    _ExpandedName = None
    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2675, 12)
    _Documentation = None
STD_ANON_21._CF_enumeration = pyxb.binding.facets.CF_enumeration(value_datatype=STD_ANON_21, enum_prefix=None)
STD_ANON_21.Hg = STD_ANON_21._CF_enumeration.addEnumeration(unicode_value='Hg', tag='Hg')
STD_ANON_21.Xe = STD_ANON_21._CF_enumeration.addEnumeration(unicode_value='Xe', tag='Xe')
STD_ANON_21.HgXe = STD_ANON_21._CF_enumeration.addEnumeration(unicode_value='HgXe', tag='HgXe')
STD_ANON_21.Other = STD_ANON_21._CF_enumeration.addEnumeration(unicode_value='Other', tag='Other')
STD_ANON_21._InitializeFacetMap(STD_ANON_21._CF_enumeration)
_module_typeBindings.STD_ANON_21 = STD_ANON_21

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

    """An atomic simple type."""

    _ExpandedName = None
    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2705, 12)
    _Documentation = None
STD_ANON_22._CF_enumeration = pyxb.binding.facets.CF_enumeration(value_datatype=STD_ANON_22, enum_prefix=None)
STD_ANON_22.Incandescent = STD_ANON_22._CF_enumeration.addEnumeration(unicode_value='Incandescent', tag='Incandescent')
STD_ANON_22.Halogen = STD_ANON_22._CF_enumeration.addEnumeration(unicode_value='Halogen', tag='Halogen')
STD_ANON_22.Other = STD_ANON_22._CF_enumeration.addEnumeration(unicode_value='Other', tag='Other')
STD_ANON_22._InitializeFacetMap(STD_ANON_22._CF_enumeration)
_module_typeBindings.STD_ANON_22 = STD_ANON_22

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

    """An atomic simple type."""

    _ExpandedName = None
    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2809, 10)
    _Documentation = None
STD_ANON_23._CF_whiteSpace = pyxb.binding.facets.CF_whiteSpace(value=pyxb.binding.facets._WhiteSpace_enum.preserve)
STD_ANON_23._InitializeFacetMap(STD_ANON_23._CF_whiteSpace)
_module_typeBindings.STD_ANON_23 = STD_ANON_23

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

    """An atomic simple type."""

    _ExpandedName = None
    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2822, 10)
    _Documentation = None
STD_ANON_24._CF_whiteSpace = pyxb.binding.facets.CF_whiteSpace(value=pyxb.binding.facets._WhiteSpace_enum.preserve)
STD_ANON_24._InitializeFacetMap(STD_ANON_24._CF_whiteSpace)
_module_typeBindings.STD_ANON_24 = STD_ANON_24

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

    """
                  A description of a Medium used for the lens.
                  The Medium is the actual immersion medium used in this case.
                """

    _ExpandedName = None
    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3152, 12)
    _Documentation = '\n                  A description of a Medium used for the lens.\n                  The Medium is the actual immersion medium used in this case.\n                '
STD_ANON_25._CF_enumeration = pyxb.binding.facets.CF_enumeration(value_datatype=STD_ANON_25, enum_prefix=None)
STD_ANON_25.Air = STD_ANON_25._CF_enumeration.addEnumeration(unicode_value='Air', tag='Air')
STD_ANON_25.Oil = STD_ANON_25._CF_enumeration.addEnumeration(unicode_value='Oil', tag='Oil')
STD_ANON_25.Water = STD_ANON_25._CF_enumeration.addEnumeration(unicode_value='Water', tag='Water')
STD_ANON_25.Glycerol = STD_ANON_25._CF_enumeration.addEnumeration(unicode_value='Glycerol', tag='Glycerol')
STD_ANON_25.Other = STD_ANON_25._CF_enumeration.addEnumeration(unicode_value='Other', tag='Other')
STD_ANON_25._InitializeFacetMap(STD_ANON_25._CF_enumeration)
_module_typeBindings.STD_ANON_25 = STD_ANON_25

# Atomic simple type: {http://www.openmicroscopy.org/Schemas/OME/2016-06}LSID
class LSID (pyxb.binding.datatypes.string):

    """
        Either LSID or internal consistent IDs for the file
        See: http://www.openmicroscopy.org/site/support/file-formats/working-with-ome-xml/id-and-lsid
      """

    _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'LSID')
    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3182, 2)
    _Documentation = '\n        Either LSID or internal consistent IDs for the file\n        See: http://www.openmicroscopy.org/site/support/file-formats/working-with-ome-xml/id-and-lsid\n      '
LSID._CF_pattern = pyxb.binding.facets.CF_pattern()
LSID._CF_pattern.addPattern(pattern='(urn:lsid:([\\w\\-\\.]+\\.[\\w\\-\\.]+)+:\\S+:\\S+)|(\\S+:\\S+)')
LSID._InitializeFacetMap(LSID._CF_pattern)
Namespace.addCategoryObject('typeBinding', 'LSID', LSID)
_module_typeBindings.LSID = LSID

# Atomic simple type: {http://www.openmicroscopy.org/Schemas/OME/2016-06}base64Binary
class base64Binary (pyxb.binding.datatypes.base64Binary):

    """An atomic simple type."""

    _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'base64Binary')
    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3285, 2)
    _Documentation = None
base64Binary._InitializeFacetMap()
Namespace.addCategoryObject('typeBinding', 'base64Binary', base64Binary)
_module_typeBindings.base64Binary = base64Binary

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

    """An atomic simple type."""

    _ExpandedName = None
    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3310, 8)
    _Documentation = None
STD_ANON_26._CF_enumeration = pyxb.binding.facets.CF_enumeration(value_datatype=STD_ANON_26, enum_prefix=None)
STD_ANON_26.zlib = STD_ANON_26._CF_enumeration.addEnumeration(unicode_value='zlib', tag='zlib')
STD_ANON_26.bzip2 = STD_ANON_26._CF_enumeration.addEnumeration(unicode_value='bzip2', tag='bzip2')
STD_ANON_26.none = STD_ANON_26._CF_enumeration.addEnumeration(unicode_value='none', tag='none')
STD_ANON_26._InitializeFacetMap(STD_ANON_26._CF_enumeration)
_module_typeBindings.STD_ANON_26 = STD_ANON_26

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

    """An atomic simple type."""

    _ExpandedName = None
    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3332, 12)
    _Documentation = None
STD_ANON_27._CF_enumeration = pyxb.binding.facets.CF_enumeration(value_datatype=STD_ANON_27, enum_prefix=None)
STD_ANON_27.zlib = STD_ANON_27._CF_enumeration.addEnumeration(unicode_value='zlib', tag='zlib')
STD_ANON_27.bzip2 = STD_ANON_27._CF_enumeration.addEnumeration(unicode_value='bzip2', tag='bzip2')
STD_ANON_27.none = STD_ANON_27._CF_enumeration.addEnumeration(unicode_value='none', tag='none')
STD_ANON_27._InitializeFacetMap(STD_ANON_27._CF_enumeration)
_module_typeBindings.STD_ANON_27 = STD_ANON_27

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

    """An atomic simple type."""

    _ExpandedName = None
    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3466, 8)
    _Documentation = None
STD_ANON_28._CF_whiteSpace = pyxb.binding.facets.CF_whiteSpace(value=pyxb.binding.facets._WhiteSpace_enum.preserve)
STD_ANON_28._InitializeFacetMap(STD_ANON_28._CF_whiteSpace)
_module_typeBindings.STD_ANON_28 = STD_ANON_28

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

    """An atomic simple type."""

    _ExpandedName = None
    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3778, 10)
    _Documentation = None
STD_ANON_29._CF_whiteSpace = pyxb.binding.facets.CF_whiteSpace(value=pyxb.binding.facets._WhiteSpace_enum.preserve)
STD_ANON_29._InitializeFacetMap(STD_ANON_29._CF_whiteSpace)
_module_typeBindings.STD_ANON_29 = STD_ANON_29

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

    """
            The rule used to decide which parts of the shape to
            fill. [enumeration]
          """

    _ExpandedName = None
    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3831, 6)
    _Documentation = '\n            The rule used to decide which parts of the shape to\n            fill. [enumeration]\n          '
STD_ANON_30._CF_enumeration = pyxb.binding.facets.CF_enumeration(value_datatype=STD_ANON_30, enum_prefix=None)
STD_ANON_30.EvenOdd = STD_ANON_30._CF_enumeration.addEnumeration(unicode_value='EvenOdd', tag='EvenOdd')
STD_ANON_30.NonZero = STD_ANON_30._CF_enumeration.addEnumeration(unicode_value='NonZero', tag='NonZero')
STD_ANON_30._InitializeFacetMap(STD_ANON_30._CF_enumeration)
_module_typeBindings.STD_ANON_30 = STD_ANON_30

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

    """
            The font family used to draw the text. [enumeration]
            Note: these values are all lower case so they match
            the standard HTML/CSS values. "fantasy" has been
            included for completeness; we do not recommend its
            regular use. This attribute is under consideration
            for removal from the OME-XML schema.
          """

    _ExpandedName = None
    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3876, 6)
    _Documentation = '\n            The font family used to draw the text. [enumeration]\n            Note: these values are all lower case so they match\n            the standard HTML/CSS values. "fantasy" has been\n            included for completeness; we do not recommend its\n            regular use. This attribute is under consideration\n            for removal from the OME-XML schema.\n          '
STD_ANON_31._CF_enumeration = pyxb.binding.facets.CF_enumeration(value_datatype=STD_ANON_31, enum_prefix=None)
STD_ANON_31.serif = STD_ANON_31._CF_enumeration.addEnumeration(unicode_value='serif', tag='serif')
STD_ANON_31.sans_serif = STD_ANON_31._CF_enumeration.addEnumeration(unicode_value='sans-serif', tag='sans_serif')
STD_ANON_31.cursive = STD_ANON_31._CF_enumeration.addEnumeration(unicode_value='cursive', tag='cursive')
STD_ANON_31.fantasy = STD_ANON_31._CF_enumeration.addEnumeration(unicode_value='fantasy', tag='fantasy')
STD_ANON_31.monospace = STD_ANON_31._CF_enumeration.addEnumeration(unicode_value='monospace', tag='monospace')
STD_ANON_31._InitializeFacetMap(STD_ANON_31._CF_enumeration)
_module_typeBindings.STD_ANON_31 = STD_ANON_31

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

    """
            The style and weight applied to the text.  [enumeration]
            This is a simplified combination of the HTML/CSS
            attributes font-style AND font-weight.
          """

    _ExpandedName = None
    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3911, 6)
    _Documentation = '\n            The style and weight applied to the text.  [enumeration]\n            This is a simplified combination of the HTML/CSS\n            attributes font-style AND font-weight.\n          '
STD_ANON_32._CF_enumeration = pyxb.binding.facets.CF_enumeration(value_datatype=STD_ANON_32, enum_prefix=None)
STD_ANON_32.Bold = STD_ANON_32._CF_enumeration.addEnumeration(unicode_value='Bold', tag='Bold')
STD_ANON_32.BoldItalic = STD_ANON_32._CF_enumeration.addEnumeration(unicode_value='BoldItalic', tag='BoldItalic')
STD_ANON_32.Italic = STD_ANON_32._CF_enumeration.addEnumeration(unicode_value='Italic', tag='Italic')
STD_ANON_32.Normal = STD_ANON_32._CF_enumeration.addEnumeration(unicode_value='Normal', tag='Normal')
STD_ANON_32._InitializeFacetMap(STD_ANON_32._CF_enumeration)
_module_typeBindings.STD_ANON_32 = STD_ANON_32

# Atomic simple type: {http://www.openmicroscopy.org/Schemas/OME/2016-06}Marker
class Marker (pyxb.binding.datatypes.string, pyxb.binding.basis.enumeration_mixin):

    """
        Shape of marker on the end of a line. [enumeration]
      """

    _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'Marker')
    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4287, 2)
    _Documentation = '\n        Shape of marker on the end of a line. [enumeration]\n      '
Marker._CF_enumeration = pyxb.binding.facets.CF_enumeration(value_datatype=Marker, enum_prefix=None)
Marker.Arrow = Marker._CF_enumeration.addEnumeration(unicode_value='Arrow', tag='Arrow')
Marker._InitializeFacetMap(Marker._CF_enumeration)
Namespace.addCategoryObject('typeBinding', 'Marker', Marker)
_module_typeBindings.Marker = Marker

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

    """An atomic simple type."""

    _ExpandedName = None
    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4320, 10)
    _Documentation = None
STD_ANON_33._CF_whiteSpace = pyxb.binding.facets.CF_whiteSpace(value=pyxb.binding.facets._WhiteSpace_enum.preserve)
STD_ANON_33._InitializeFacetMap(STD_ANON_33._CF_whiteSpace)
_module_typeBindings.STD_ANON_33 = STD_ANON_33

# Atomic simple type: {http://www.openmicroscopy.org/Schemas/OME/2016-06}NamingConvention
class NamingConvention (pyxb.binding.datatypes.string, pyxb.binding.basis.enumeration_mixin):

    """
        Predefined list of values for the well labels
      """

    _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'NamingConvention')
    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4447, 2)
    _Documentation = '\n        Predefined list of values for the well labels\n      '
NamingConvention._CF_enumeration = pyxb.binding.facets.CF_enumeration(value_datatype=NamingConvention, enum_prefix=None)
NamingConvention.letter = NamingConvention._CF_enumeration.addEnumeration(unicode_value='letter', tag='letter')
NamingConvention.number = NamingConvention._CF_enumeration.addEnumeration(unicode_value='number', tag='number')
NamingConvention._InitializeFacetMap(NamingConvention._CF_enumeration)
Namespace.addCategoryObject('typeBinding', 'NamingConvention', NamingConvention)
_module_typeBindings.NamingConvention = NamingConvention

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

    """An atomic simple type."""

    _ExpandedName = None
    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4513, 10)
    _Documentation = None
STD_ANON_34._CF_whiteSpace = pyxb.binding.facets.CF_whiteSpace(value=pyxb.binding.facets._WhiteSpace_enum.preserve)
STD_ANON_34._InitializeFacetMap(STD_ANON_34._CF_whiteSpace)
_module_typeBindings.STD_ANON_34 = STD_ANON_34

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

    """An atomic simple type."""

    _ExpandedName = None
    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4580, 10)
    _Documentation = None
STD_ANON_35._CF_whiteSpace = pyxb.binding.facets.CF_whiteSpace(value=pyxb.binding.facets._WhiteSpace_enum.preserve)
STD_ANON_35._InitializeFacetMap(STD_ANON_35._CF_whiteSpace)
_module_typeBindings.STD_ANON_35 = STD_ANON_35

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

    """An atomic simple type."""

    _ExpandedName = None
    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4678, 10)
    _Documentation = None
STD_ANON_36._CF_whiteSpace = pyxb.binding.facets.CF_whiteSpace(value=pyxb.binding.facets._WhiteSpace_enum.preserve)
STD_ANON_36._InitializeFacetMap(STD_ANON_36._CF_whiteSpace)
_module_typeBindings.STD_ANON_36 = STD_ANON_36

# List simple type: [anonymous]
# superclasses pyxb.binding.datatypes.anySimpleType
class STD_ANON_37 (pyxb.binding.basis.STD_list):

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

    _ExpandedName = None
    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 958, 8)
    _Documentation = None

    _ItemType = STD_ANON_6
STD_ANON_37._InitializeFacetMap()
_module_typeBindings.STD_ANON_37 = STD_ANON_37

# List simple type: [anonymous]
# superclasses pyxb.binding.datatypes.anySimpleType
class STD_ANON_38 (pyxb.binding.basis.STD_list):

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

    _ExpandedName = None
    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1291, 8)
    _Documentation = None

    _ItemType = STD_ANON_12
STD_ANON_38._InitializeFacetMap()
_module_typeBindings.STD_ANON_38 = STD_ANON_38

# Atomic simple type: {http://www.openmicroscopy.org/Schemas/OME/2016-06}ProjectID
class ProjectID (LSID):

    """An atomic simple type."""

    _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'ProjectID')
    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3193, 2)
    _Documentation = None
ProjectID._CF_pattern = pyxb.binding.facets.CF_pattern()
ProjectID._CF_pattern.addPattern(pattern='(urn:lsid:([\\w\\-\\.]+\\.[\\w\\-\\.]+)+:Project:\\S+)|(Project:\\S+)')
ProjectID._InitializeFacetMap(ProjectID._CF_pattern)
Namespace.addCategoryObject('typeBinding', 'ProjectID', ProjectID)
_module_typeBindings.ProjectID = ProjectID

# Atomic simple type: {http://www.openmicroscopy.org/Schemas/OME/2016-06}DatasetID
class DatasetID (LSID):

    """An atomic simple type."""

    _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'DatasetID')
    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3198, 2)
    _Documentation = None
DatasetID._CF_pattern = pyxb.binding.facets.CF_pattern()
DatasetID._CF_pattern.addPattern(pattern='(urn:lsid:([\\w\\-\\.]+\\.[\\w\\-\\.]+)+:Dataset:\\S+)|(Dataset:\\S+)')
DatasetID._InitializeFacetMap(DatasetID._CF_pattern)
Namespace.addCategoryObject('typeBinding', 'DatasetID', DatasetID)
_module_typeBindings.DatasetID = DatasetID

# Atomic simple type: {http://www.openmicroscopy.org/Schemas/OME/2016-06}ImageID
class ImageID (LSID):

    """An atomic simple type."""

    _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'ImageID')
    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3203, 2)
    _Documentation = None
ImageID._CF_pattern = pyxb.binding.facets.CF_pattern()
ImageID._CF_pattern.addPattern(pattern='(urn:lsid:([\\w\\-\\.]+\\.[\\w\\-\\.]+)+:Image:\\S+)|(Image:\\S+)')
ImageID._InitializeFacetMap(ImageID._CF_pattern)
Namespace.addCategoryObject('typeBinding', 'ImageID', ImageID)
_module_typeBindings.ImageID = ImageID

# Atomic simple type: {http://www.openmicroscopy.org/Schemas/OME/2016-06}FolderID
class FolderID (LSID):

    """An atomic simple type."""

    _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'FolderID')
    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3208, 2)
    _Documentation = None
FolderID._CF_pattern = pyxb.binding.facets.CF_pattern()
FolderID._CF_pattern.addPattern(pattern='(urn:lsid:([\\w\\-\\.]+\\.[\\w\\-\\.]+)+:Folder:\\S+)|(Folder:\\S+)')
FolderID._InitializeFacetMap(FolderID._CF_pattern)
Namespace.addCategoryObject('typeBinding', 'FolderID', FolderID)
_module_typeBindings.FolderID = FolderID

# Atomic simple type: {http://www.openmicroscopy.org/Schemas/OME/2016-06}ExperimenterID
class ExperimenterID (LSID):

    """An atomic simple type."""

    _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'ExperimenterID')
    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3213, 2)
    _Documentation = None
ExperimenterID._CF_pattern = pyxb.binding.facets.CF_pattern()
ExperimenterID._CF_pattern.addPattern(pattern='(urn:lsid:([\\w\\-\\.]+\\.[\\w\\-\\.]+)+:Experimenter:\\S+)|(Experimenter:\\S+)')
ExperimenterID._InitializeFacetMap(ExperimenterID._CF_pattern)
Namespace.addCategoryObject('typeBinding', 'ExperimenterID', ExperimenterID)
_module_typeBindings.ExperimenterID = ExperimenterID

# Atomic simple type: {http://www.openmicroscopy.org/Schemas/OME/2016-06}ExperimenterGroupID
class ExperimenterGroupID (LSID):

    """An atomic simple type."""

    _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'ExperimenterGroupID')
    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3218, 2)
    _Documentation = None
ExperimenterGroupID._CF_pattern = pyxb.binding.facets.CF_pattern()
ExperimenterGroupID._CF_pattern.addPattern(pattern='(urn:lsid:([\\w\\-\\.]+\\.[\\w\\-\\.]+)+:ExperimenterGroup:\\S+)|(ExperimenterGroup:\\S+)')
ExperimenterGroupID._InitializeFacetMap(ExperimenterGroupID._CF_pattern)
Namespace.addCategoryObject('typeBinding', 'ExperimenterGroupID', ExperimenterGroupID)
_module_typeBindings.ExperimenterGroupID = ExperimenterGroupID

# Atomic simple type: {http://www.openmicroscopy.org/Schemas/OME/2016-06}ExperimentID
class ExperimentID (LSID):

    """An atomic simple type."""

    _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'ExperimentID')
    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3223, 2)
    _Documentation = None
ExperimentID._CF_pattern = pyxb.binding.facets.CF_pattern()
ExperimentID._CF_pattern.addPattern(pattern='(urn:lsid:([\\w\\-\\.]+\\.[\\w\\-\\.]+)+:Experiment:\\S+)|(Experiment:\\S+)')
ExperimentID._InitializeFacetMap(ExperimentID._CF_pattern)
Namespace.addCategoryObject('typeBinding', 'ExperimentID', ExperimentID)
_module_typeBindings.ExperimentID = ExperimentID

# Atomic simple type: {http://www.openmicroscopy.org/Schemas/OME/2016-06}MicrobeamManipulationID
class MicrobeamManipulationID (LSID):

    """An atomic simple type."""

    _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'MicrobeamManipulationID')
    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3228, 2)
    _Documentation = None
MicrobeamManipulationID._CF_pattern = pyxb.binding.facets.CF_pattern()
MicrobeamManipulationID._CF_pattern.addPattern(pattern='(urn:lsid:([\\w\\-\\.]+\\.[\\w\\-\\.]+)+:MicrobeamManipulation:\\S+)|(MicrobeamManipulation:\\S+)')
MicrobeamManipulationID._InitializeFacetMap(MicrobeamManipulationID._CF_pattern)
Namespace.addCategoryObject('typeBinding', 'MicrobeamManipulationID', MicrobeamManipulationID)
_module_typeBindings.MicrobeamManipulationID = MicrobeamManipulationID

# Atomic simple type: {http://www.openmicroscopy.org/Schemas/OME/2016-06}InstrumentID
class InstrumentID (LSID):

    """An atomic simple type."""

    _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'InstrumentID')
    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3233, 2)
    _Documentation = None
InstrumentID._CF_pattern = pyxb.binding.facets.CF_pattern()
InstrumentID._CF_pattern.addPattern(pattern='(urn:lsid:([\\w\\-\\.]+\\.[\\w\\-\\.]+)+:Instrument:\\S+)|(Instrument:\\S+)')
InstrumentID._InitializeFacetMap(InstrumentID._CF_pattern)
Namespace.addCategoryObject('typeBinding', 'InstrumentID', InstrumentID)
_module_typeBindings.InstrumentID = InstrumentID

# Atomic simple type: {http://www.openmicroscopy.org/Schemas/OME/2016-06}ObjectiveID
class ObjectiveID (LSID):

    """An atomic simple type."""

    _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'ObjectiveID')
    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3238, 2)
    _Documentation = None
ObjectiveID._CF_pattern = pyxb.binding.facets.CF_pattern()
ObjectiveID._CF_pattern.addPattern(pattern='(urn:lsid:([\\w\\-\\.]+\\.[\\w\\-\\.]+)+:Objective:\\S+)|(Objective:\\S+)')
ObjectiveID._InitializeFacetMap(ObjectiveID._CF_pattern)
Namespace.addCategoryObject('typeBinding', 'ObjectiveID', ObjectiveID)
_module_typeBindings.ObjectiveID = ObjectiveID

# Atomic simple type: {http://www.openmicroscopy.org/Schemas/OME/2016-06}LightSourceID
class LightSourceID (LSID):

    """An atomic simple type."""

    _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'LightSourceID')
    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3243, 2)
    _Documentation = None
LightSourceID._CF_pattern = pyxb.binding.facets.CF_pattern()
LightSourceID._CF_pattern.addPattern(pattern='(urn:lsid:([\\w\\-\\.]+\\.[\\w\\-\\.]+)+:LightSource:\\S+)|(LightSource:\\S+)')
LightSourceID._InitializeFacetMap(LightSourceID._CF_pattern)
Namespace.addCategoryObject('typeBinding', 'LightSourceID', LightSourceID)
_module_typeBindings.LightSourceID = LightSourceID

# Atomic simple type: {http://www.openmicroscopy.org/Schemas/OME/2016-06}DichroicID
class DichroicID (LSID):

    """An atomic simple type."""

    _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'DichroicID')
    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3248, 2)
    _Documentation = None
DichroicID._CF_pattern = pyxb.binding.facets.CF_pattern()
DichroicID._CF_pattern.addPattern(pattern='(urn:lsid:([\\w\\-\\.]+\\.[\\w\\-\\.]+)+:Dichroic:\\S+)|(Dichroic:\\S+)')
DichroicID._InitializeFacetMap(DichroicID._CF_pattern)
Namespace.addCategoryObject('typeBinding', 'DichroicID', DichroicID)
_module_typeBindings.DichroicID = DichroicID

# Atomic simple type: {http://www.openmicroscopy.org/Schemas/OME/2016-06}FilterID
class FilterID (LSID):

    """An atomic simple type."""

    _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'FilterID')
    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3253, 2)
    _Documentation = None
FilterID._CF_pattern = pyxb.binding.facets.CF_pattern()
FilterID._CF_pattern.addPattern(pattern='(urn:lsid:([\\w\\-\\.]+\\.[\\w\\-\\.]+)+:Filter:\\S+)|(Filter:\\S+)')
FilterID._InitializeFacetMap(FilterID._CF_pattern)
Namespace.addCategoryObject('typeBinding', 'FilterID', FilterID)
_module_typeBindings.FilterID = FilterID

# Atomic simple type: {http://www.openmicroscopy.org/Schemas/OME/2016-06}FilterSetID
class FilterSetID (LSID):

    """An atomic simple type."""

    _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'FilterSetID')
    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3258, 2)
    _Documentation = None
FilterSetID._CF_pattern = pyxb.binding.facets.CF_pattern()
FilterSetID._CF_pattern.addPattern(pattern='(urn:lsid:([\\w\\-\\.]+\\.[\\w\\-\\.]+)+:FilterSet:\\S+)|(FilterSet:\\S+)')
FilterSetID._InitializeFacetMap(FilterSetID._CF_pattern)
Namespace.addCategoryObject('typeBinding', 'FilterSetID', FilterSetID)
_module_typeBindings.FilterSetID = FilterSetID

# Atomic simple type: {http://www.openmicroscopy.org/Schemas/OME/2016-06}DetectorID
class DetectorID (LSID):

    """An atomic simple type."""

    _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'DetectorID')
    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3263, 2)
    _Documentation = None
DetectorID._CF_pattern = pyxb.binding.facets.CF_pattern()
DetectorID._CF_pattern.addPattern(pattern='(urn:lsid:([\\w\\-\\.]+\\.[\\w\\-\\.]+)+:Detector:\\S+)|(Detector:\\S+)')
DetectorID._InitializeFacetMap(DetectorID._CF_pattern)
Namespace.addCategoryObject('typeBinding', 'DetectorID', DetectorID)
_module_typeBindings.DetectorID = DetectorID

# Atomic simple type: {http://www.openmicroscopy.org/Schemas/OME/2016-06}PixelsID
class PixelsID (LSID):

    """An atomic simple type."""

    _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'PixelsID')
    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3268, 2)
    _Documentation = None
PixelsID._CF_pattern = pyxb.binding.facets.CF_pattern()
PixelsID._CF_pattern.addPattern(pattern='(urn:lsid:([\\w\\-\\.]+\\.[\\w\\-\\.]+)+:Pixels:\\S+)|(Pixels:\\S+)')
PixelsID._InitializeFacetMap(PixelsID._CF_pattern)
Namespace.addCategoryObject('typeBinding', 'PixelsID', PixelsID)
_module_typeBindings.PixelsID = PixelsID

# Atomic simple type: {http://www.openmicroscopy.org/Schemas/OME/2016-06}ChannelID
class ChannelID (LSID):

    """An atomic simple type."""

    _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'ChannelID')
    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3273, 2)
    _Documentation = None
ChannelID._CF_pattern = pyxb.binding.facets.CF_pattern()
ChannelID._CF_pattern.addPattern(pattern='(urn:lsid:([\\w\\-\\.]+\\.[\\w\\-\\.]+)+:Channel:\\S+)|(Channel:\\S+)')
ChannelID._InitializeFacetMap(ChannelID._CF_pattern)
Namespace.addCategoryObject('typeBinding', 'ChannelID', ChannelID)
_module_typeBindings.ChannelID = ChannelID

# Atomic simple type: {http://www.openmicroscopy.org/Schemas/OME/2016-06}ModuleID
class ModuleID (LSID):

    """An atomic simple type."""

    _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'ModuleID')
    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3278, 2)
    _Documentation = None
ModuleID._CF_pattern = pyxb.binding.facets.CF_pattern()
ModuleID._CF_pattern.addPattern(pattern='(urn:lsid:([\\w\\-\\.]+\\.[\\w\\-\\.]+)+:Module:\\S+)|(Module:\\S+)')
ModuleID._InitializeFacetMap(ModuleID._CF_pattern)
Namespace.addCategoryObject('typeBinding', 'ModuleID', ModuleID)
_module_typeBindings.ModuleID = ModuleID

# Atomic simple type: [anonymous]
class STD_ANON_39 (NonNegativeLong):

    """An atomic simple type."""

    _ExpandedName = None
    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3353, 12)
    _Documentation = None
STD_ANON_39._InitializeFacetMap()
_module_typeBindings.STD_ANON_39 = STD_ANON_39

# Atomic simple type: {http://www.openmicroscopy.org/Schemas/OME/2016-06}AnnotationID
class AnnotationID (LSID):

    """An atomic simple type."""

    _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'AnnotationID')
    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3500, 2)
    _Documentation = None
AnnotationID._CF_pattern = pyxb.binding.facets.CF_pattern()
AnnotationID._CF_pattern.addPattern(pattern='(urn:lsid:([\\w\\-\\.]+\\.[\\w\\-\\.]+)+:Annotation:\\S+)|(Annotation:\\S+)')
AnnotationID._InitializeFacetMap(AnnotationID._CF_pattern)
Namespace.addCategoryObject('typeBinding', 'AnnotationID', AnnotationID)
_module_typeBindings.AnnotationID = AnnotationID

# Atomic simple type: {http://www.openmicroscopy.org/Schemas/OME/2016-06}ROIID
class ROIID (LSID):

    """An atomic simple type."""

    _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'ROIID')
    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4275, 2)
    _Documentation = None
ROIID._CF_pattern = pyxb.binding.facets.CF_pattern()
ROIID._CF_pattern.addPattern(pattern='(urn:lsid:([\\w\\-\\.]+\\.[\\w\\-\\.]+)+:\\S+)|(\\S+)')
ROIID._InitializeFacetMap(ROIID._CF_pattern)
Namespace.addCategoryObject('typeBinding', 'ROIID', ROIID)
_module_typeBindings.ROIID = ROIID

# Atomic simple type: {http://www.openmicroscopy.org/Schemas/OME/2016-06}ShapeID
class ShapeID (LSID):

    """An atomic simple type."""

    _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'ShapeID')
    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4281, 2)
    _Documentation = None
ShapeID._CF_pattern = pyxb.binding.facets.CF_pattern()
ShapeID._CF_pattern.addPattern(pattern='(urn:lsid:([\\w\\-\\.]+\\.[\\w\\-\\.]+)+:Shape:\\S+)|(Shape:\\S+)')
ShapeID._InitializeFacetMap(ShapeID._CF_pattern)
Namespace.addCategoryObject('typeBinding', 'ShapeID', ShapeID)
_module_typeBindings.ShapeID = ShapeID

# Atomic simple type: {http://www.openmicroscopy.org/Schemas/OME/2016-06}PlateID
class PlateID (LSID):

    """An atomic simple type."""

    _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'PlateID')
    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4492, 2)
    _Documentation = None
PlateID._CF_pattern = pyxb.binding.facets.CF_pattern()
PlateID._CF_pattern.addPattern(pattern='(urn:lsid:([\\w\\-\\.]+\\.[\\w\\-\\.]+)+:Plate:\\S+)|(Plate:\\S+)')
PlateID._InitializeFacetMap(PlateID._CF_pattern)
Namespace.addCategoryObject('typeBinding', 'PlateID', PlateID)
_module_typeBindings.PlateID = PlateID

# Atomic simple type: {http://www.openmicroscopy.org/Schemas/OME/2016-06}ReagentID
class ReagentID (LSID):

    """An atomic simple type."""

    _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'ReagentID')
    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4554, 2)
    _Documentation = None
ReagentID._CF_pattern = pyxb.binding.facets.CF_pattern()
ReagentID._CF_pattern.addPattern(pattern='(urn:lsid:([\\w\\-\\.]+\\.[\\w\\-\\.]+)+:Reagent:\\S+)|(Reagent:\\S+)')
ReagentID._InitializeFacetMap(ReagentID._CF_pattern)
Namespace.addCategoryObject('typeBinding', 'ReagentID', ReagentID)
_module_typeBindings.ReagentID = ReagentID

# Atomic simple type: {http://www.openmicroscopy.org/Schemas/OME/2016-06}ScreenID
class ScreenID (LSID):

    """An atomic simple type."""

    _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'ScreenID')
    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4654, 2)
    _Documentation = None
ScreenID._CF_pattern = pyxb.binding.facets.CF_pattern()
ScreenID._CF_pattern.addPattern(pattern='(urn:lsid:([\\w\\-\\.]+\\.[\\w\\-\\.]+)+:Screen:\\S+)|(Screen:\\S+)')
ScreenID._InitializeFacetMap(ScreenID._CF_pattern)
Namespace.addCategoryObject('typeBinding', 'ScreenID', ScreenID)
_module_typeBindings.ScreenID = ScreenID

# Atomic simple type: {http://www.openmicroscopy.org/Schemas/OME/2016-06}PlateAcquisitionID
class PlateAcquisitionID (LSID):

    """An atomic simple type."""

    _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'PlateAcquisitionID')
    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4720, 2)
    _Documentation = None
PlateAcquisitionID._CF_pattern = pyxb.binding.facets.CF_pattern()
PlateAcquisitionID._CF_pattern.addPattern(pattern='(urn:lsid:([\\w\\-\\.]+\\.[\\w\\-\\.]+)+:PlateAcquisition:\\S+)|(PlateAcquisition:\\S+)')
PlateAcquisitionID._InitializeFacetMap(PlateAcquisitionID._CF_pattern)
Namespace.addCategoryObject('typeBinding', 'PlateAcquisitionID', PlateAcquisitionID)
_module_typeBindings.PlateAcquisitionID = PlateAcquisitionID

# Atomic simple type: {http://www.openmicroscopy.org/Schemas/OME/2016-06}WellID
class WellID (LSID):

    """An atomic simple type."""

    _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'WellID')
    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4804, 2)
    _Documentation = None
WellID._CF_pattern = pyxb.binding.facets.CF_pattern()
WellID._CF_pattern.addPattern(pattern='(urn:lsid:([\\w\\-\\.]+\\.[\\w\\-\\.]+)+:Well:\\S+)|(Well:\\S+)')
WellID._InitializeFacetMap(WellID._CF_pattern)
Namespace.addCategoryObject('typeBinding', 'WellID', WellID)
_module_typeBindings.WellID = WellID

# Atomic simple type: {http://www.openmicroscopy.org/Schemas/OME/2016-06}WellSampleID
class WellSampleID (LSID):

    """An atomic simple type."""

    _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'WellSampleID')
    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4877, 2)
    _Documentation = None
WellSampleID._CF_pattern = pyxb.binding.facets.CF_pattern()
WellSampleID._CF_pattern.addPattern(pattern='(urn:lsid:([\\w\\-\\.]+\\.[\\w\\-\\.]+)+:WellSample:\\S+)|(WellSample:\\S+)')
WellSampleID._InitializeFacetMap(WellSampleID._CF_pattern)
Namespace.addCategoryObject('typeBinding', 'WellSampleID', WellSampleID)
_module_typeBindings.WellSampleID = WellSampleID

# Complex type {http://www.openmicroscopy.org/Schemas/OME/2016-06}ManufacturerSpec with content type EMPTY
class ManufacturerSpec (pyxb.binding.basis.complexTypeDefinition):
    """
        This is the base from which many microscope components are extended. E.g Objective, Filter etc.
        Provides attributes for recording common properties of these components such as Manufacturer name, Model etc,
        all of which are optional.
      """
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_EMPTY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'ManufacturerSpec')
    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1429, 2)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Attribute Manufacturer uses Python identifier Manufacturer
    __Manufacturer = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'Manufacturer'), 'Manufacturer', '__httpwww_openmicroscopy_orgSchemasOME2016_06_ManufacturerSpec_Manufacturer', pyxb.binding.datatypes.string)
    __Manufacturer._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1438, 4)
    __Manufacturer._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1438, 4)
    
    Manufacturer = property(__Manufacturer.value, __Manufacturer.set, None, '\n          The manufacturer of the component. [plain text string]\n        ')

    
    # Attribute Model uses Python identifier Model
    __Model = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'Model'), 'Model', '__httpwww_openmicroscopy_orgSchemasOME2016_06_ManufacturerSpec_Model', pyxb.binding.datatypes.string)
    __Model._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1445, 4)
    __Model._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1445, 4)
    
    Model = property(__Model.value, __Model.set, None, '\n          The Model of the component. [plain text string]\n        ')

    
    # Attribute SerialNumber uses Python identifier SerialNumber
    __SerialNumber = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'SerialNumber'), 'SerialNumber', '__httpwww_openmicroscopy_orgSchemasOME2016_06_ManufacturerSpec_SerialNumber', pyxb.binding.datatypes.string)
    __SerialNumber._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1452, 4)
    __SerialNumber._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1452, 4)
    
    SerialNumber = property(__SerialNumber.value, __SerialNumber.set, None, '\n          The serial number of the component. [plain text string]\n        ')

    
    # Attribute LotNumber uses Python identifier LotNumber
    __LotNumber = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'LotNumber'), 'LotNumber', '__httpwww_openmicroscopy_orgSchemasOME2016_06_ManufacturerSpec_LotNumber', pyxb.binding.datatypes.string)
    __LotNumber._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1459, 4)
    __LotNumber._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1459, 4)
    
    LotNumber = property(__LotNumber.value, __LotNumber.set, None, '\n          The lot number of the component. [plain text string]\n        ')

    _ElementMap.update({
        
    })
    _AttributeMap.update({
        __Manufacturer.name() : __Manufacturer,
        __Model.name() : __Model,
        __SerialNumber.name() : __SerialNumber,
        __LotNumber.name() : __LotNumber
    })
_module_typeBindings.ManufacturerSpec = ManufacturerSpec
Namespace.addCategoryObject('typeBinding', 'ManufacturerSpec', ManufacturerSpec)


# Complex type {http://www.openmicroscopy.org/Schemas/OME/2016-06}Map with content type ELEMENT_ONLY
class Map (pyxb.binding.basis.complexTypeDefinition):
    """
        This is a Mapping of key/value pairs.
      """
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'Map')
    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1555, 2)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}M uses Python identifier M
    __M = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'M'), 'M', '__httpwww_openmicroscopy_orgSchemasOME2016_06_Map_httpwww_openmicroscopy_orgSchemasOME2016_06M', True, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1563, 6), )

    
    M = property(__M.value, __M.set, None, ' This is a key/value pair used to build up a Mapping. The\n          Element and Attribute name are kept to single letters to minimize the\n          length at the expense of readability as they are likely to occur many\n          times. ')

    _ElementMap.update({
        __M.name() : __M
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.Map = Map
Namespace.addCategoryObject('typeBinding', 'Map', Map)


# Complex type [anonymous] with content type SIMPLE
class CTD_ANON (pyxb.binding.basis.complexTypeDefinition):
    """ This is a key/value pair used to build up a Mapping. The
          Element and Attribute name are kept to single letters to minimize the
          length at the expense of readability as they are likely to occur many
          times. """
    _TypeDefinition = pyxb.binding.datatypes.string
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_SIMPLE
    _Abstract = False
    _ExpandedName = None
    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1571, 8)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.string
    
    # Attribute K uses Python identifier K
    __K = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'K'), 'K', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_K', pyxb.binding.datatypes.string)
    __K._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1574, 14)
    __K._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1574, 14)
    
    K = property(__K.value, __K.set, None, None)

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


# Complex type [anonymous] with content type ELEMENT_ONLY
class CTD_ANON_ (pyxb.binding.basis.complexTypeDefinition):
    """A description of the light path"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = None
    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2416, 4)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}ExcitationFilterRef uses Python identifier ExcitationFilterRef
    __ExcitationFilterRef = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'ExcitationFilterRef'), 'ExcitationFilterRef', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON__httpwww_openmicroscopy_orgSchemasOME2016_06ExcitationFilterRef', True, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2418, 8), )

    
    ExcitationFilterRef = property(__ExcitationFilterRef.value, __ExcitationFilterRef.set, None, '\n              The Filters placed in the Excitation light path.\n            ')

    
    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}EmissionFilterRef uses Python identifier EmissionFilterRef
    __EmissionFilterRef = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'EmissionFilterRef'), 'EmissionFilterRef', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON__httpwww_openmicroscopy_orgSchemasOME2016_06EmissionFilterRef', True, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2427, 8), )

    
    EmissionFilterRef = property(__EmissionFilterRef.value, __EmissionFilterRef.set, None, '\n              The Filters placed in the Emission light path.\n            ')

    
    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}DichroicRef uses Python identifier DichroicRef
    __DichroicRef = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'DichroicRef'), 'DichroicRef', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON__httpwww_openmicroscopy_orgSchemasOME2016_06DichroicRef', False, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2443, 2), )

    
    DichroicRef = property(__DichroicRef.value, __DichroicRef.set, None, None)

    
    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}AnnotationRef uses Python identifier AnnotationRef
    __AnnotationRef = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'AnnotationRef'), 'AnnotationRef', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON__httpwww_openmicroscopy_orgSchemasOME2016_06AnnotationRef', True, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3435, 2), )

    
    AnnotationRef = property(__AnnotationRef.value, __AnnotationRef.set, None, '\n        The AnnotationRef element is a reference to an element derived\n        from the CommonAnnotation element.\n      ')

    _ElementMap.update({
        __ExcitationFilterRef.name() : __ExcitationFilterRef,
        __EmissionFilterRef.name() : __EmissionFilterRef,
        __DichroicRef.name() : __DichroicRef,
        __AnnotationRef.name() : __AnnotationRef
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.CTD_ANON_ = CTD_ANON_


# Complex type [anonymous] with content type ELEMENT_ONLY
class CTD_ANON_2 (pyxb.binding.basis.complexTypeDefinition):
    """
        The rights holder of this data and the rights held.
      """
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = None
    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2801, 4)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}RightsHolder uses Python identifier RightsHolder
    __RightsHolder = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'RightsHolder'), 'RightsHolder', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_2_httpwww_openmicroscopy_orgSchemasOME2016_06RightsHolder', False, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2803, 8), )

    
    RightsHolder = property(__RightsHolder.value, __RightsHolder.set, None, ' The rights holder for this data. [plain-text multi-line string]\n            e.g. "Copyright (C) 2002 - 2016 Open Microscopy Environment"\n            ')

    
    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}RightsHeld uses Python identifier RightsHeld
    __RightsHeld = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'RightsHeld'), 'RightsHeld', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_2_httpwww_openmicroscopy_orgSchemasOME2016_06RightsHeld', False, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2815, 8), )

    
    RightsHeld = property(__RightsHeld.value, __RightsHeld.set, None, '\n              The rights held by the rights holder. [plain-text multi-line string]\n              e.g. "All rights reserved" or "Creative Commons Attribution 3.0 Unported License"\n            ')

    _ElementMap.update({
        __RightsHolder.name() : __RightsHolder,
        __RightsHeld.name() : __RightsHeld
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.CTD_ANON_2 = CTD_ANON_2


# Complex type {http://www.openmicroscopy.org/Schemas/OME/2016-06}Reference with content type EMPTY
class Reference (pyxb.binding.basis.complexTypeDefinition):
    """
        Reference is an empty complex type that is contained and extended by all the *Ref elements and also the Settings Complex Type
        Each *Ref element defines an attribute named ID of simple type *ID and no other information
        Each simple type *ID is restricted to the base type LSID with an appropriate pattern
      """
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_EMPTY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'Reference')
    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2833, 2)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    _ElementMap.update({
        
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.Reference = Reference
Namespace.addCategoryObject('typeBinding', 'Reference', Reference)


# Complex type [anonymous] with content type ELEMENT_ONLY
class CTD_ANON_3 (pyxb.binding.basis.complexTypeDefinition):
    """
        An unordered collection of annotation attached to objects in the OME data model.
      """
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = None
    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3419, 4)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}FileAnnotation uses Python identifier FileAnnotation
    __FileAnnotation = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'FileAnnotation'), 'FileAnnotation', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_3_httpwww_openmicroscopy_orgSchemasOME2016_06FileAnnotation', True, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3554, 2), )

    
    FileAnnotation = property(__FileAnnotation.value, __FileAnnotation.set, None, '\n        A file object annotation\n      ')

    
    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}XMLAnnotation uses Python identifier XMLAnnotation
    __XMLAnnotation = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'XMLAnnotation'), 'XMLAnnotation', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_3_httpwww_openmicroscopy_orgSchemasOME2016_06XMLAnnotation', True, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3571, 2), )

    
    XMLAnnotation = property(__XMLAnnotation.value, __XMLAnnotation.set, None, '\n        An general xml annotation. The contents of this is not processed as OME XML but should still be well-formed XML.\n      ')

    
    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}ListAnnotation uses Python identifier ListAnnotation
    __ListAnnotation = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'ListAnnotation'), 'ListAnnotation', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_3_httpwww_openmicroscopy_orgSchemasOME2016_06ListAnnotation', True, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3594, 2), )

    
    ListAnnotation = property(__ListAnnotation.value, __ListAnnotation.set, None, '\n        This annotation is a grouping object. It uses the sequence of\n        annotation refs from the base Annotation to form the list.\n      ')

    
    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}CommentAnnotation uses Python identifier CommentAnnotation
    __CommentAnnotation = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'CommentAnnotation'), 'CommentAnnotation', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_3_httpwww_openmicroscopy_orgSchemasOME2016_06CommentAnnotation', True, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3608, 2), )

    
    CommentAnnotation = property(__CommentAnnotation.value, __CommentAnnotation.set, None, '\n        A simple comment annotation\n      ')

    
    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}LongAnnotation uses Python identifier LongAnnotation
    __LongAnnotation = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'LongAnnotation'), 'LongAnnotation', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_3_httpwww_openmicroscopy_orgSchemasOME2016_06LongAnnotation', True, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3625, 2), )

    
    LongAnnotation = property(__LongAnnotation.value, __LongAnnotation.set, None, '\n        A simple numerical annotation of type xsd:long\n      ')

    
    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}DoubleAnnotation uses Python identifier DoubleAnnotation
    __DoubleAnnotation = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'DoubleAnnotation'), 'DoubleAnnotation', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_3_httpwww_openmicroscopy_orgSchemasOME2016_06DoubleAnnotation', True, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3642, 2), )

    
    DoubleAnnotation = property(__DoubleAnnotation.value, __DoubleAnnotation.set, None, '\n        A simple numerical annotation of type xsd:double\n      ')

    
    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}BooleanAnnotation uses Python identifier BooleanAnnotation
    __BooleanAnnotation = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'BooleanAnnotation'), 'BooleanAnnotation', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_3_httpwww_openmicroscopy_orgSchemasOME2016_06BooleanAnnotation', True, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3659, 2), )

    
    BooleanAnnotation = property(__BooleanAnnotation.value, __BooleanAnnotation.set, None, '\n        A simple boolean annotation of type xsd:boolean\n      ')

    
    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}TimestampAnnotation uses Python identifier TimestampAnnotation
    __TimestampAnnotation = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'TimestampAnnotation'), 'TimestampAnnotation', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_3_httpwww_openmicroscopy_orgSchemasOME2016_06TimestampAnnotation', True, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3676, 2), )

    
    TimestampAnnotation = property(__TimestampAnnotation.value, __TimestampAnnotation.set, None, '\n        A date/time annotation of type xsd:dateTime\n      ')

    
    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}TagAnnotation uses Python identifier TagAnnotation
    __TagAnnotation = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'TagAnnotation'), 'TagAnnotation', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_3_httpwww_openmicroscopy_orgSchemasOME2016_06TagAnnotation', True, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3693, 2), )

    
    TagAnnotation = property(__TagAnnotation.value, __TagAnnotation.set, None, '\n        A tag annotation (represents a tag or a tagset)\n      ')

    
    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}TermAnnotation uses Python identifier TermAnnotation
    __TermAnnotation = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'TermAnnotation'), 'TermAnnotation', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_3_httpwww_openmicroscopy_orgSchemasOME2016_06TermAnnotation', True, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3710, 2), )

    
    TermAnnotation = property(__TermAnnotation.value, __TermAnnotation.set, None, '\n        A ontology term annotation\n      ')

    
    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}MapAnnotation uses Python identifier MapAnnotation
    __MapAnnotation = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'MapAnnotation'), 'MapAnnotation', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_3_httpwww_openmicroscopy_orgSchemasOME2016_06MapAnnotation', True, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3727, 2), )

    
    MapAnnotation = property(__MapAnnotation.value, __MapAnnotation.set, None, '\n        An map annotation. The contents of this is a list of key/value pairs.\n      ')

    _ElementMap.update({
        __FileAnnotation.name() : __FileAnnotation,
        __XMLAnnotation.name() : __XMLAnnotation,
        __ListAnnotation.name() : __ListAnnotation,
        __CommentAnnotation.name() : __CommentAnnotation,
        __LongAnnotation.name() : __LongAnnotation,
        __DoubleAnnotation.name() : __DoubleAnnotation,
        __BooleanAnnotation.name() : __BooleanAnnotation,
        __TimestampAnnotation.name() : __TimestampAnnotation,
        __TagAnnotation.name() : __TagAnnotation,
        __TermAnnotation.name() : __TermAnnotation,
        __MapAnnotation.name() : __MapAnnotation
    })
    _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('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3583, 14)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    _HasWildcardElement = True
    _ElementMap.update({
        
    })
    _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('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3760, 12)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}ShapeGroup uses Python identifier ShapeGroup
    __ShapeGroup = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'ShapeGroup'), 'ShapeGroup', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_5_httpwww_openmicroscopy_orgSchemasOME2016_06ShapeGroup', True, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3795, 2), )

    
    ShapeGroup = property(__ShapeGroup.value, __ShapeGroup.set, None, None)

    _ElementMap.update({
        __ShapeGroup.name() : __ShapeGroup
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.CTD_ANON_5 = CTD_ANON_5


# Complex type {http://www.openmicroscopy.org/Schemas/OME/2016-06}AffineTransform with content type EMPTY
class AffineTransform (pyxb.binding.basis.complexTypeDefinition):
    """
        A matrix used to transform the shape.
        ⎡ A00, A01, A02 ⎤
        ⎢ A10, A11, A12 ⎥
        ⎣ 0,   0,   1   ⎦
      """
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_EMPTY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'AffineTransform')
    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4258, 2)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Attribute A00 uses Python identifier A00
    __A00 = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'A00'), 'A00', '__httpwww_openmicroscopy_orgSchemasOME2016_06_AffineTransform_A00', pyxb.binding.datatypes.float, required=True)
    __A00._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4267, 4)
    __A00._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4267, 4)
    
    A00 = property(__A00.value, __A00.set, None, None)

    
    # Attribute A10 uses Python identifier A10
    __A10 = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'A10'), 'A10', '__httpwww_openmicroscopy_orgSchemasOME2016_06_AffineTransform_A10', pyxb.binding.datatypes.float, required=True)
    __A10._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4268, 4)
    __A10._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4268, 4)
    
    A10 = property(__A10.value, __A10.set, None, None)

    
    # Attribute A01 uses Python identifier A01
    __A01 = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'A01'), 'A01', '__httpwww_openmicroscopy_orgSchemasOME2016_06_AffineTransform_A01', pyxb.binding.datatypes.float, required=True)
    __A01._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4269, 4)
    __A01._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4269, 4)
    
    A01 = property(__A01.value, __A01.set, None, None)

    
    # Attribute A11 uses Python identifier A11
    __A11 = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'A11'), 'A11', '__httpwww_openmicroscopy_orgSchemasOME2016_06_AffineTransform_A11', pyxb.binding.datatypes.float, required=True)
    __A11._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4270, 4)
    __A11._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4270, 4)
    
    A11 = property(__A11.value, __A11.set, None, None)

    
    # Attribute A02 uses Python identifier A02
    __A02 = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'A02'), 'A02', '__httpwww_openmicroscopy_orgSchemasOME2016_06_AffineTransform_A02', pyxb.binding.datatypes.float, required=True)
    __A02._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4271, 4)
    __A02._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4271, 4)
    
    A02 = property(__A02.value, __A02.set, None, None)

    
    # Attribute A12 uses Python identifier A12
    __A12 = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'A12'), 'A12', '__httpwww_openmicroscopy_orgSchemasOME2016_06_AffineTransform_A12', pyxb.binding.datatypes.float, required=True)
    __A12._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4272, 4)
    __A12._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4272, 4)
    
    A12 = property(__A12.value, __A12.set, None, None)

    _ElementMap.update({
        
    })
    _AttributeMap.update({
        __A00.name() : __A00,
        __A10.name() : __A10,
        __A01.name() : __A01,
        __A11.name() : __A11,
        __A02.name() : __A02,
        __A12.name() : __A12
    })
_module_typeBindings.AffineTransform = AffineTransform
Namespace.addCategoryObject('typeBinding', 'AffineTransform', AffineTransform)


# Complex type [anonymous] with content type ELEMENT_ONLY
class CTD_ANON_6 (pyxb.binding.basis.complexTypeDefinition):
    """
        The OME element is a container for all information objects accessible by OME.
        These information objects include descriptions of the imaging experiments
        and the people who perform them, descriptions of the microscope, the resulting
        images and how they were acquired, the analyses performed on those images,
        and the analysis results themselves.
        An OME file may contain any or all of this information.

        With the creation of the Metadata Only Companion OME-XML and Binary Only OME-TIFF files
        the top level OME node has changed slightly.
        It can EITHER:
        Contain all the previously expected elements
        OR:
        Contain a single BinaryOnly element that points at
        its Metadata Only Companion OME-XML file.
      """
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = None
    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 59, 4)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}BinaryOnly uses Python identifier BinaryOnly
    __BinaryOnly = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'BinaryOnly'), 'BinaryOnly', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_6_httpwww_openmicroscopy_orgSchemasOME2016_06BinaryOnly', False, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 79, 10), )

    
    BinaryOnly = property(__BinaryOnly.value, __BinaryOnly.set, None, ' Pointer to an external metadata file. If this\n              element is present, then no other metadata may be present in this\n              file, i.e. this file is a place-holder. ')

    
    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}Image uses Python identifier Image
    __Image = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'Image'), 'Image', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_6_httpwww_openmicroscopy_orgSchemasOME2016_06Image', True, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 209, 2), )

    
    Image = property(__Image.value, __Image.set, None, "\n        This element describes the actual image and its meta-data.\n        The elements that are references (ending in Ref or Settings) refer to\n        elements defined outside of the Image element. Ref elements are simple\n        links, while Settings elements are links with additional values.\n\n        If any of the required Image attributes or elements are missing, its\n        guaranteed to be an invalid document. The required attributes and\n        elements are ID and Pixels.\n\n        ExperimenterRef is required for all Images with well formed LSIDs.\n        ImageType is a vendor-specific designation of the type of image this is.\n        Examples of ImageType include 'STK', 'SoftWorx', etc.\n        The Name attributes are in all cases the name of the element\n        instance. In this case, the name of the image, not necessarily the filename.\n        Physical size of pixels are microns[\xb5m].\n      ")

    
    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}Instrument uses Python identifier Instrument
    __Instrument = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'Instrument'), 'Instrument', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_6_httpwww_openmicroscopy_orgSchemasOME2016_06Instrument', True, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 979, 2), )

    
    Instrument = property(__Instrument.value, __Instrument.set, None, "\n        This element describes the instrument used to capture the Image.\n        It is primarily a container for manufacturer's model and catalog\n        numbers for the Microscope, LightSource, Detector, Objective and\n        Filters components.\n        The Objective element contains the additional elements LensNA and Magnification.\n        The Filters element can be composed either of separate excitation,\n        emission filters and a dichroic mirror or a single filter set.\n        Within the Image itself, a reference is made to this one Filter element.\n        There may be multiple light sources, detectors, objectives and filters on a microscope.\n        Each of these has their own ID attribute, which can be referred to from Channel.\n        It is understood that the light path configuration can be different\n        for each channel, but cannot be different for each timepoint or\n        each plane of an XYZ stack.\n      ")

    
    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}Project uses Python identifier Project
    __Project = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'Project'), 'Project', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_6_httpwww_openmicroscopy_orgSchemasOME2016_06Project', True, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1101, 2), )

    
    Project = property(__Project.value, __Project.set, None, '\n        The Project ID is required.\n        Datasets can be grouped into projects using a many-to-many relationship.\n        A Dataset may belong to one or more Projects by including one or more ProjectRef elements which refer to Project IDs.\n        Projects do not directly contain images - only by virtue of containing datasets, which themselves contain images.\n      ')

    
    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}ExperimenterGroup uses Python identifier ExperimenterGroup
    __ExperimenterGroup = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'ExperimenterGroup'), 'ExperimenterGroup', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_6_httpwww_openmicroscopy_orgSchemasOME2016_06ExperimenterGroup', True, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1142, 2), )

    
    ExperimenterGroup = property(__ExperimenterGroup.value, __ExperimenterGroup.set, None, '\n        The ExperimenterGroupID is required.\n        Information should ideally be specified for at least one Leader as a contact for the group.\n        The Leaders are themselves Experimenters.\n      ')

    
    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}Dataset uses Python identifier Dataset
    __Dataset = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'Dataset'), 'Dataset', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_6_httpwww_openmicroscopy_orgSchemasOME2016_06Dataset', True, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1201, 2), )

    
    Dataset = property(__Dataset.value, __Dataset.set, None, '\n        An element specifying a collection of images that are always processed together.\n        Images can belong to more than one Dataset, and a Dataset may contain more than one Image.\n        Images contain one or more DatasetRef elements to specify what datasets they belong to.\n        Once a Dataset has been processed in any way, its collection of images cannot be altered.\n        The ExperimenterRef and ExperimenterGroupRef elements specify the person and group this Dataset belongs to.\n        Projects may contain one or more Datasets, and Datasets may belong to one or more Projects.\n        This relationship is specified by listing DatasetRef elements within the Project element.\n      ')

    
    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}Experiment uses Python identifier Experiment
    __Experiment = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'Experiment'), 'Experiment', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_6_httpwww_openmicroscopy_orgSchemasOME2016_06Experiment', True, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1251, 2), )

    
    Experiment = property(__Experiment.value, __Experiment.set, None, "\n        This element describes the type of experiment.  The required Type attribute must contain one or more entries from the following list:\n        FP FRET Time-lapse 4-D+ Screen Immunocytochemistry FISH Electrophysiology  Ion-Imaging Colocalization PGI/Documentation\n        FRAP Photoablation Optical-Trapping Photoactivation Fluorescence-Lifetime Spectral-Imaging Other\n        FP refers to fluorescent proteins, PGI/Documentation is not a 'data' image.\n        The optional Description element may contain free text to further describe the experiment.\n      ")

    
    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}Experimenter uses Python identifier Experimenter
    __Experimenter = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'Experimenter'), 'Experimenter', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_6_httpwww_openmicroscopy_orgSchemasOME2016_06Experimenter', True, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1320, 2), )

    
    Experimenter = property(__Experimenter.value, __Experimenter.set, None, '\n        This element describes a person who performed an imaging experiment.\n        This person may also be a user of the OME system, in which case the UserName element contains their login name.\n        Experimenters may belong to one or more groups which are specified using one or more ExperimenterGroupRef elements.\n      ')

    
    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}Folder uses Python identifier Folder
    __Folder = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'Folder'), 'Folder', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_6_httpwww_openmicroscopy_orgSchemasOME2016_06Folder', True, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1377, 2), )

    
    Folder = property(__Folder.value, __Folder.set, None, '\n        An element specifying a possibly heterogeneous collection of data.\n        Folders may contain Folders so that data may be organized within a tree of Folders.\n        Data may be in multiple Folders but a Folder may not be in more than one other Folder.\n      ')

    
    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}Rights uses Python identifier Rights
    __Rights = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'Rights'), 'Rights', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_6_httpwww_openmicroscopy_orgSchemasOME2016_06Rights', False, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2794, 2), )

    
    Rights = property(__Rights.value, __Rights.set, None, '\n        The rights holder of this data and the rights held.\n      ')

    
    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}StructuredAnnotations uses Python identifier StructuredAnnotations
    __StructuredAnnotations = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'StructuredAnnotations'), 'StructuredAnnotations', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_6_httpwww_openmicroscopy_orgSchemasOME2016_06StructuredAnnotations', False, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3413, 2), )

    
    StructuredAnnotations = property(__StructuredAnnotations.value, __StructuredAnnotations.set, None, '\n        An unordered collection of annotation attached to objects in the OME data model.\n      ')

    
    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}ROI uses Python identifier ROI
    __ROI = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'ROI'), 'ROI', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_6_httpwww_openmicroscopy_orgSchemasOME2016_06ROI', True, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3746, 2), )

    
    ROI = property(__ROI.value, __ROI.set, None, "\n        A four dimensional 'Region of Interest'.\n        If they are not used, and the Image has more than one plane,\n        the entire set of planes is assumed to be included in the ROI.\n        Multiple ROIs may be specified.\n      ")

    
    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}Plate uses Python identifier Plate
    __Plate = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'Plate'), 'Plate', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_6_httpwww_openmicroscopy_orgSchemasOME2016_06Plate', True, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4300, 2), )

    
    Plate = property(__Plate.value, __Plate.set, None, '\n        This element identifies microtiter plates within a screen.\n        A plate can belong to more than one screen.\n        The Screen(s) that a plate belongs to are specified by the ScreenRef element.\n        The Plate ID and Name attributes are required.\n        The Wells in a plate are numbers from the top-left corner in a grid starting at zero.\n        i.e. The top-left well of a plate is index (0,0)\n      ')

    
    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}Screen uses Python identifier Screen
    __Screen = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'Screen'), 'Screen', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_6_httpwww_openmicroscopy_orgSchemasOME2016_06Screen', True, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4560, 2), )

    
    Screen = property(__Screen.value, __Screen.set, None, "\n        The Screen element is a grouping for Plates.\n        The required attribute is the Screen's Name and ID - both must be unique within the document.\n        The Screen element may contain an ExternalRef attribute that refers to an external database.\n        A description of the screen may be specified in the Description element.\n        Screens may contain overlapping sets of Plates i.e.      Screens and Plates have a many-to-many relationship.\n        Plates contain one or more ScreenRef elements to specify what screens they belong to.\n      ")

    
    # Attribute UUID uses Python identifier UUID
    __UUID = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'UUID'), 'UUID', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_6_UUID', _module_typeBindings.UniversallyUniqueIdentifier)
    __UUID._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 107, 6)
    __UUID._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 107, 6)
    
    UUID = property(__UUID.value, __UUID.set, None, '\n            This unique identifier is used to keep track of multi part files.\n            It allows the links between files to survive renaming.\n\n            While OPTIONAL in the general case this is REQUIRED in a\n            MetadataOnly Companion to a collection of BinaryOnly files.\n          ')

    
    # Attribute Creator uses Python identifier Creator
    __Creator = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'Creator'), 'Creator', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_6_Creator', pyxb.binding.datatypes.string)
    __Creator._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 118, 6)
    __Creator._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 118, 6)
    
    Creator = property(__Creator.value, __Creator.set, None, '\n            This is the name of the creating application of the OME-XML\n            and preferably its full version.\n            e.g "CompanyName, SoftwareName, V2.6.3456"\n            This is optional but we hope it will be set by applications\n            writing out OME-XML from scratch.\n          ')

    _ElementMap.update({
        __BinaryOnly.name() : __BinaryOnly,
        __Image.name() : __Image,
        __Instrument.name() : __Instrument,
        __Project.name() : __Project,
        __ExperimenterGroup.name() : __ExperimenterGroup,
        __Dataset.name() : __Dataset,
        __Experiment.name() : __Experiment,
        __Experimenter.name() : __Experimenter,
        __Folder.name() : __Folder,
        __Rights.name() : __Rights,
        __StructuredAnnotations.name() : __StructuredAnnotations,
        __ROI.name() : __ROI,
        __Plate.name() : __Plate,
        __Screen.name() : __Screen
    })
    _AttributeMap.update({
        __UUID.name() : __UUID,
        __Creator.name() : __Creator
    })
_module_typeBindings.CTD_ANON_6 = CTD_ANON_6


# Complex type [anonymous] with content type EMPTY
class CTD_ANON_7 (pyxb.binding.basis.complexTypeDefinition):
    """ Pointer to an external metadata file. If this
              element is present, then no other metadata may be present in this
              file, i.e. this file is a place-holder. """
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_EMPTY
    _Abstract = False
    _ExpandedName = None
    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 85, 12)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Attribute MetadataFile uses Python identifier MetadataFile
    __MetadataFile = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'MetadataFile'), 'MetadataFile', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_7_MetadataFile', pyxb.binding.datatypes.string, required=True)
    __MetadataFile._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 86, 14)
    __MetadataFile._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 86, 14)
    
    MetadataFile = property(__MetadataFile.value, __MetadataFile.set, None, ' Filename of the OME-XML metadata file for\n                  this binary data. If the file cannot be found, a search can\n                  be performed based on the UUID. ')

    
    # Attribute UUID uses Python identifier UUID
    __UUID = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'UUID'), 'UUID', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_7_UUID', _module_typeBindings.UniversallyUniqueIdentifier, required=True)
    __UUID._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 93, 14)
    __UUID._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 93, 14)
    
    UUID = property(__UUID.value, __UUID.set, None, ' The unique identifier of another OME-XML\n                  block whose metadata describes the binary data in this file.\n                  This UUID is considered authoritative regardless of\n                  mismatches in the filename. ')

    _ElementMap.update({
        
    })
    _AttributeMap.update({
        __MetadataFile.name() : __MetadataFile,
        __UUID.name() : __UUID
    })
_module_typeBindings.CTD_ANON_7 = CTD_ANON_7


# Complex type [anonymous] with content type ELEMENT_ONLY
class CTD_ANON_8 (pyxb.binding.basis.complexTypeDefinition):
    """
        The Plane object holds microscope stage and image timing data
        for a given channel/z-section/timepoint.
      """
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = None
    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 486, 4)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}HashSHA1 uses Python identifier HashSHA1
    __HashSHA1 = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'HashSHA1'), 'HashSHA1', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_8_httpwww_openmicroscopy_orgSchemasOME2016_06HashSHA1', False, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 496, 10), )

    
    HashSHA1 = property(__HashSHA1.value, __HashSHA1.set, None, None)

    
    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}AnnotationRef uses Python identifier AnnotationRef
    __AnnotationRef = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'AnnotationRef'), 'AnnotationRef', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_8_httpwww_openmicroscopy_orgSchemasOME2016_06AnnotationRef', True, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3435, 2), )

    
    AnnotationRef = property(__AnnotationRef.value, __AnnotationRef.set, None, '\n        The AnnotationRef element is a reference to an element derived\n        from the CommonAnnotation element.\n      ')

    
    # Attribute TheZ uses Python identifier TheZ
    __TheZ = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'TheZ'), 'TheZ', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_8_TheZ', _module_typeBindings.NonNegativeInt, required=True)
    __TheZ._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 504, 6)
    __TheZ._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 504, 6)
    
    TheZ = property(__TheZ.value, __TheZ.set, None, '\n            The Z-section this plane is for. [units:none]\n            This is numbered from 0.\n          ')

    
    # Attribute TheT uses Python identifier TheT
    __TheT = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'TheT'), 'TheT', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_8_TheT', _module_typeBindings.NonNegativeInt, required=True)
    __TheT._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 512, 6)
    __TheT._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 512, 6)
    
    TheT = property(__TheT.value, __TheT.set, None, '\n            The timepoint this plane is for. [units:none]\n            This is numbered from 0.\n          ')

    
    # Attribute TheC uses Python identifier TheC
    __TheC = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'TheC'), 'TheC', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_8_TheC', _module_typeBindings.NonNegativeInt, required=True)
    __TheC._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 520, 6)
    __TheC._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 520, 6)
    
    TheC = property(__TheC.value, __TheC.set, None, '\n            The channel this plane is for. [units:none]\n            This is numbered from 0.\n          ')

    
    # Attribute DeltaT uses Python identifier DeltaT
    __DeltaT = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'DeltaT'), 'DeltaT', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_8_DeltaT', pyxb.binding.datatypes.float)
    __DeltaT._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 528, 6)
    __DeltaT._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 528, 6)
    
    DeltaT = property(__DeltaT.value, __DeltaT.set, None, '\n            Time since the beginning of the experiment.\n            Units are set by DeltaTUnit.\n          ')

    
    # Attribute DeltaTUnit uses Python identifier DeltaTUnit
    __DeltaTUnit = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'DeltaTUnit'), 'DeltaTUnit', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_8_DeltaTUnit', _module_typeBindings.UnitsTime, unicode_default='s')
    __DeltaTUnit._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 536, 6)
    __DeltaTUnit._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 536, 6)
    
    DeltaTUnit = property(__DeltaTUnit.value, __DeltaTUnit.set, None, 'The units of the DeltaT - default:seconds[s].')

    
    # Attribute ExposureTime uses Python identifier ExposureTime
    __ExposureTime = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'ExposureTime'), 'ExposureTime', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_8_ExposureTime', pyxb.binding.datatypes.float)
    __ExposureTime._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 541, 6)
    __ExposureTime._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 541, 6)
    
    ExposureTime = property(__ExposureTime.value, __ExposureTime.set, None, '\n            The length of the exposure.\n            Units are set by ExposureTimeUnit.\n          ')

    
    # Attribute ExposureTimeUnit uses Python identifier ExposureTimeUnit
    __ExposureTimeUnit = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'ExposureTimeUnit'), 'ExposureTimeUnit', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_8_ExposureTimeUnit', _module_typeBindings.UnitsTime, unicode_default='s')
    __ExposureTimeUnit._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 549, 6)
    __ExposureTimeUnit._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 549, 6)
    
    ExposureTimeUnit = property(__ExposureTimeUnit.value, __ExposureTimeUnit.set, None, 'The units of the ExposureTime - default:seconds[s].')

    
    # Attribute PositionX uses Python identifier PositionX
    __PositionX = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'PositionX'), 'PositionX', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_8_PositionX', pyxb.binding.datatypes.float)
    __PositionX._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 554, 6)
    __PositionX._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 554, 6)
    
    PositionX = property(__PositionX.value, __PositionX.set, None, '\n            The X position of the stage. Units are set by PositionXUnit.\n          ')

    
    # Attribute PositionXUnit uses Python identifier PositionXUnit
    __PositionXUnit = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'PositionXUnit'), 'PositionXUnit', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_8_PositionXUnit', _module_typeBindings.UnitsLength, unicode_default='reference frame')
    __PositionXUnit._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 561, 6)
    __PositionXUnit._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 561, 6)
    
    PositionXUnit = property(__PositionXUnit.value, __PositionXUnit.set, None, 'The units of the X stage position - default:[reference frame].')

    
    # Attribute PositionY uses Python identifier PositionY
    __PositionY = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'PositionY'), 'PositionY', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_8_PositionY', pyxb.binding.datatypes.float)
    __PositionY._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 566, 6)
    __PositionY._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 566, 6)
    
    PositionY = property(__PositionY.value, __PositionY.set, None, '\n            The Y position of the stage. Units are set by PositionYUnit.\n          ')

    
    # Attribute PositionYUnit uses Python identifier PositionYUnit
    __PositionYUnit = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'PositionYUnit'), 'PositionYUnit', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_8_PositionYUnit', _module_typeBindings.UnitsLength, unicode_default='reference frame')
    __PositionYUnit._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 573, 6)
    __PositionYUnit._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 573, 6)
    
    PositionYUnit = property(__PositionYUnit.value, __PositionYUnit.set, None, 'The units of the Y stage position - default:[reference frame].')

    
    # Attribute PositionZ uses Python identifier PositionZ
    __PositionZ = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'PositionZ'), 'PositionZ', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_8_PositionZ', pyxb.binding.datatypes.float)
    __PositionZ._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 578, 6)
    __PositionZ._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 578, 6)
    
    PositionZ = property(__PositionZ.value, __PositionZ.set, None, '\n            The Z position of the stage. Units are set by PositionZUnit.\n          ')

    
    # Attribute PositionZUnit uses Python identifier PositionZUnit
    __PositionZUnit = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'PositionZUnit'), 'PositionZUnit', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_8_PositionZUnit', _module_typeBindings.UnitsLength, unicode_default='reference frame')
    __PositionZUnit._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 585, 6)
    __PositionZUnit._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 585, 6)
    
    PositionZUnit = property(__PositionZUnit.value, __PositionZUnit.set, None, 'The units of the Z stage position - default:[reference frame].')

    _ElementMap.update({
        __HashSHA1.name() : __HashSHA1,
        __AnnotationRef.name() : __AnnotationRef
    })
    _AttributeMap.update({
        __TheZ.name() : __TheZ,
        __TheT.name() : __TheT,
        __TheC.name() : __TheC,
        __DeltaT.name() : __DeltaT,
        __DeltaTUnit.name() : __DeltaTUnit,
        __ExposureTime.name() : __ExposureTime,
        __ExposureTimeUnit.name() : __ExposureTimeUnit,
        __PositionX.name() : __PositionX,
        __PositionXUnit.name() : __PositionXUnit,
        __PositionY.name() : __PositionY,
        __PositionYUnit.name() : __PositionYUnit,
        __PositionZ.name() : __PositionZ,
        __PositionZUnit.name() : __PositionZUnit
    })
_module_typeBindings.CTD_ANON_8 = CTD_ANON_8


# Complex type [anonymous] with content type ELEMENT_ONLY
class CTD_ANON_9 (pyxb.binding.basis.complexTypeDefinition):
    """
        This described the location of the pixel data in a tiff file.
      """
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = None
    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 799, 4)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}UUID uses Python identifier UUID
    __UUID = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'UUID'), 'UUID', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_9_httpwww_openmicroscopy_orgSchemasOME2016_06UUID', False, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 801, 8), )

    
    UUID = property(__UUID.value, __UUID.set, None, '\n              This must be used when the IFDs are located in another file.\n              Note: It is permissible for this to be self referential.\n            ')

    
    # Attribute IFD uses Python identifier IFD
    __IFD = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'IFD'), 'IFD', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_9_IFD', _module_typeBindings.NonNegativeInt, unicode_default='0')
    __IFD._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 828, 6)
    __IFD._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 828, 6)
    
    IFD = property(__IFD.value, __IFD.set, None, '\n            Gives the IFD(s) for which this element is applicable. Indexed from 0.\n            Default is 0 (the first IFD). [units:none]\n          ')

    
    # Attribute FirstZ uses Python identifier FirstZ
    __FirstZ = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'FirstZ'), 'FirstZ', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_9_FirstZ', _module_typeBindings.NonNegativeInt, unicode_default='0')
    __FirstZ._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 836, 6)
    __FirstZ._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 836, 6)
    
    FirstZ = property(__FirstZ.value, __FirstZ.set, None, '\n            Gives the Z position of the image plane at the specified IFD. Indexed from 0.\n            Default is 0 (the first Z position). [units:none]\n          ')

    
    # Attribute FirstT uses Python identifier FirstT
    __FirstT = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'FirstT'), 'FirstT', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_9_FirstT', _module_typeBindings.NonNegativeInt, unicode_default='0')
    __FirstT._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 844, 6)
    __FirstT._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 844, 6)
    
    FirstT = property(__FirstT.value, __FirstT.set, None, '\n            Gives the T position of the image plane at the specified IFD. Indexed from 0.\n            Default is 0 (the first T position). [units:none]\n          ')

    
    # Attribute FirstC uses Python identifier FirstC
    __FirstC = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'FirstC'), 'FirstC', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_9_FirstC', _module_typeBindings.NonNegativeInt, unicode_default='0')
    __FirstC._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 852, 6)
    __FirstC._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 852, 6)
    
    FirstC = property(__FirstC.value, __FirstC.set, None, '\n            Gives the C position of the image plane at the specified IFD. Indexed from 0.\n            Default is 0 (the first C position). [units:none]\n          ')

    
    # Attribute PlaneCount uses Python identifier PlaneCount
    __PlaneCount = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'PlaneCount'), 'PlaneCount', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_9_PlaneCount', _module_typeBindings.NonNegativeInt)
    __PlaneCount._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 860, 6)
    __PlaneCount._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 860, 6)
    
    PlaneCount = property(__PlaneCount.value, __PlaneCount.set, None, "\n            Gives the number of IFDs affected. Dimension order of IFDs is given by the enclosing\n            Pixels element's DimensionOrder attribute. Default is the number of IFDs in the TIFF\n            file, unless an IFD is specified, in which case the default is 1. [units:none]\n          ")

    _ElementMap.update({
        __UUID.name() : __UUID
    })
    _AttributeMap.update({
        __IFD.name() : __IFD,
        __FirstZ.name() : __FirstZ,
        __FirstT.name() : __FirstT,
        __FirstC.name() : __FirstC,
        __PlaneCount.name() : __PlaneCount
    })
_module_typeBindings.CTD_ANON_9 = CTD_ANON_9


# Complex type [anonymous] with content type SIMPLE
class CTD_ANON_10 (pyxb.binding.basis.complexTypeDefinition):
    """
              This must be used when the IFDs are located in another file.
              Note: It is permissible for this to be self referential.
            """
    _TypeDefinition = UniversallyUniqueIdentifier
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_SIMPLE
    _Abstract = False
    _ExpandedName = None
    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 808, 10)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is UniversallyUniqueIdentifier
    
    # Attribute FileName uses Python identifier FileName
    __FileName = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'FileName'), 'FileName', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_10_FileName', pyxb.binding.datatypes.string)
    __FileName._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 811, 16)
    __FileName._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 811, 16)
    
    FileName = property(__FileName.value, __FileName.set, None, '\n                      This can be used when the IFDs are located in another file.\n                      The / (forward slash) is used as the path separator.\n                      A relative path is recommended. However an absolute path can be specified.\n                      Default is to use the file the ome-xml data has been pulled from.\n                      Note: It is permissible for this to be self referential. The file image1.tiff\n                      may contain ome-xml data that has FilePath="image1.tiff" or "./image1.tiff"\n                    ')

    _ElementMap.update({
        
    })
    _AttributeMap.update({
        __FileName.name() : __FileName
    })
_module_typeBindings.CTD_ANON_10 = CTD_ANON_10


# Complex type [anonymous] with content type EMPTY
class CTD_ANON_11 (pyxb.binding.basis.complexTypeDefinition):
    """
        The StageLabel is used to specify a name and position for a stage position in the microscope's reference frame.
      """
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_EMPTY
    _Abstract = False
    _ExpandedName = None
    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 878, 4)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Attribute Name uses Python identifier Name
    __Name = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'Name'), 'Name', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_11_Name', pyxb.binding.datatypes.string, required=True)
    __Name._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 879, 6)
    __Name._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 879, 6)
    
    Name = property(__Name.value, __Name.set, None, None)

    
    # Attribute X uses Python identifier X
    __X = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'X'), 'X', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_11_X', pyxb.binding.datatypes.float)
    __X._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 880, 6)
    __X._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 880, 6)
    
    X = property(__X.value, __X.set, None, '\n            The X position of the stage label. Units are set by XUnit.\n          ')

    
    # Attribute XUnit uses Python identifier XUnit
    __XUnit = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'XUnit'), 'XUnit', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_11_XUnit', _module_typeBindings.UnitsLength, unicode_default='reference frame')
    __XUnit._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 887, 6)
    __XUnit._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 887, 6)
    
    XUnit = property(__XUnit.value, __XUnit.set, None, 'The units of the X stage position - default:[reference frame].')

    
    # Attribute Y uses Python identifier Y
    __Y = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'Y'), 'Y', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_11_Y', pyxb.binding.datatypes.float)
    __Y._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 892, 6)
    __Y._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 892, 6)
    
    Y = property(__Y.value, __Y.set, None, '\n            The Y position of the stage label. Units are set by YUnit.\n          ')

    
    # Attribute YUnit uses Python identifier YUnit
    __YUnit = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'YUnit'), 'YUnit', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_11_YUnit', _module_typeBindings.UnitsLength, unicode_default='reference frame')
    __YUnit._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 899, 6)
    __YUnit._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 899, 6)
    
    YUnit = property(__YUnit.value, __YUnit.set, None, 'The units of the Y stage position - default:[reference frame].')

    
    # Attribute Z uses Python identifier Z
    __Z = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'Z'), 'Z', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_11_Z', pyxb.binding.datatypes.float)
    __Z._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 904, 6)
    __Z._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 904, 6)
    
    Z = property(__Z.value, __Z.set, None, '\n            The Z position of the stage label. Units are set by ZUnit.\n          ')

    
    # Attribute ZUnit uses Python identifier ZUnit
    __ZUnit = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'ZUnit'), 'ZUnit', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_11_ZUnit', _module_typeBindings.UnitsLength, unicode_default='reference frame')
    __ZUnit._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 911, 6)
    __ZUnit._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 911, 6)
    
    ZUnit = property(__ZUnit.value, __ZUnit.set, None, 'The units of the Z  stage position - default:[reference frame].')

    _ElementMap.update({
        
    })
    _AttributeMap.update({
        __Name.name() : __Name,
        __X.name() : __X,
        __XUnit.name() : __XUnit,
        __Y.name() : __Y,
        __YUnit.name() : __YUnit,
        __Z.name() : __Z,
        __ZUnit.name() : __ZUnit
    })
_module_typeBindings.CTD_ANON_11 = CTD_ANON_11


# Complex type [anonymous] with content type EMPTY
class CTD_ANON_12 (ManufacturerSpec):
    """The microscope's manufacturer specification."""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_EMPTY
    _Abstract = False
    _ExpandedName = None
    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1021, 4)
    _ElementMap = ManufacturerSpec._ElementMap.copy()
    _AttributeMap = ManufacturerSpec._AttributeMap.copy()
    # Base type is ManufacturerSpec
    
    # Attribute Type uses Python identifier Type
    __Type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'Type'), 'Type', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_12_Type', _module_typeBindings.STD_ANON_7)
    __Type._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1024, 10)
    __Type._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1024, 10)
    
    Type = property(__Type.value, __Type.set, None, None)

    
    # Attribute Manufacturer inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}ManufacturerSpec
    
    # Attribute Model inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}ManufacturerSpec
    
    # Attribute SerialNumber inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}ManufacturerSpec
    
    # Attribute LotNumber inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}ManufacturerSpec
    _ElementMap.update({
        
    })
    _AttributeMap.update({
        __Type.name() : __Type
    })
_module_typeBindings.CTD_ANON_12 = CTD_ANON_12


# Complex type [anonymous] with content type ELEMENT_ONLY
class CTD_ANON_13 (pyxb.binding.basis.complexTypeDefinition):
    """
        This describes the environment that the biological sample was in
        during the experiment.
      """
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = None
    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1049, 4)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}Map uses Python identifier Map
    __Map = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'Map'), 'Map', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_13_httpwww_openmicroscopy_orgSchemasOME2016_06Map', False, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1051, 8), )

    
    Map = property(__Map.value, __Map.set, None, None)

    
    # Attribute Temperature uses Python identifier Temperature
    __Temperature = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'Temperature'), 'Temperature', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_13_Temperature', pyxb.binding.datatypes.float)
    __Temperature._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1053, 6)
    __Temperature._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1053, 6)
    
    Temperature = property(__Temperature.value, __Temperature.set, None, '\n            The Temperature is the define units.\n          ')

    
    # Attribute TemperatureUnit uses Python identifier TemperatureUnit
    __TemperatureUnit = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'TemperatureUnit'), 'TemperatureUnit', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_13_TemperatureUnit', _module_typeBindings.UnitsTemperature, unicode_default='\xb0C')
    __TemperatureUnit._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1060, 6)
    __TemperatureUnit._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1060, 6)
    
    TemperatureUnit = property(__TemperatureUnit.value, __TemperatureUnit.set, None, '\n            The units the Temperature is in - default:Celsius[\xb0C].\n          ')

    
    # Attribute AirPressure uses Python identifier AirPressure
    __AirPressure = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'AirPressure'), 'AirPressure', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_13_AirPressure', pyxb.binding.datatypes.float)
    __AirPressure._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1067, 6)
    __AirPressure._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1067, 6)
    
    AirPressure = property(__AirPressure.value, __AirPressure.set, None, '\n            AirPressure is the define units.\n          ')

    
    # Attribute AirPressureUnit uses Python identifier AirPressureUnit
    __AirPressureUnit = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'AirPressureUnit'), 'AirPressureUnit', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_13_AirPressureUnit', _module_typeBindings.UnitsPressure, unicode_default='mbar')
    __AirPressureUnit._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1074, 6)
    __AirPressureUnit._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1074, 6)
    
    AirPressureUnit = property(__AirPressureUnit.value, __AirPressureUnit.set, None, '\n            The units the AirPressure is in - default:millibars[mbar].\n          ')

    
    # Attribute Humidity uses Python identifier Humidity
    __Humidity = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'Humidity'), 'Humidity', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_13_Humidity', _module_typeBindings.PercentFraction)
    __Humidity._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1081, 6)
    __Humidity._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1081, 6)
    
    Humidity = property(__Humidity.value, __Humidity.set, None, '\n            Humidity around the sample [units:none]\n            A fraction, as a value from 0.0 to 1.0.\n          ')

    
    # Attribute CO2Percent uses Python identifier CO2Percent
    __CO2Percent = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'CO2Percent'), 'CO2Percent', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_13_CO2Percent', _module_typeBindings.PercentFraction)
    __CO2Percent._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1089, 6)
    __CO2Percent._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1089, 6)
    
    CO2Percent = property(__CO2Percent.value, __CO2Percent.set, None, '\n            Carbon Dioxide concentration around the sample [units:none]\n            A fraction, as a value from 0.0 to 1.0.\n          ')

    _ElementMap.update({
        __Map.name() : __Map
    })
    _AttributeMap.update({
        __Temperature.name() : __Temperature,
        __TemperatureUnit.name() : __TemperatureUnit,
        __AirPressure.name() : __AirPressure,
        __AirPressureUnit.name() : __AirPressureUnit,
        __Humidity.name() : __Humidity,
        __CO2Percent.name() : __CO2Percent
    })
_module_typeBindings.CTD_ANON_13 = CTD_ANON_13


# Complex type [anonymous] with content type EMPTY
class CTD_ANON_14 (pyxb.binding.basis.complexTypeDefinition):
    """
        This records the range of wavelengths that are transmitted by the filter. It also records the maximum amount of light transmitted.
      """
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_EMPTY
    _Abstract = False
    _ExpandedName = None
    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2332, 4)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Attribute CutIn uses Python identifier CutIn
    __CutIn = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'CutIn'), 'CutIn', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_14_CutIn', _module_typeBindings.PositiveFloat)
    __CutIn._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2333, 6)
    __CutIn._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2333, 6)
    
    CutIn = property(__CutIn.value, __CutIn.set, None, '\n            CutIn is the wavelength below which there is less than 50% transmittance for a filter. Units are set by CutInUnit.\n          ')

    
    # Attribute CutInUnit uses Python identifier CutInUnit
    __CutInUnit = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'CutInUnit'), 'CutInUnit', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_14_CutInUnit', _module_typeBindings.UnitsLength, unicode_default='nm')
    __CutInUnit._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2340, 6)
    __CutInUnit._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2340, 6)
    
    CutInUnit = property(__CutInUnit.value, __CutInUnit.set, None, 'The units of the CutIn - default:nanometres[nm].')

    
    # Attribute CutOut uses Python identifier CutOut
    __CutOut = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'CutOut'), 'CutOut', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_14_CutOut', _module_typeBindings.PositiveFloat)
    __CutOut._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2345, 6)
    __CutOut._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2345, 6)
    
    CutOut = property(__CutOut.value, __CutOut.set, None, '\n            CutOut is the wavelength above which there is less than 50% transmittance for a filter. Units are set by CutOutUnit.\n          ')

    
    # Attribute CutOutUnit uses Python identifier CutOutUnit
    __CutOutUnit = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'CutOutUnit'), 'CutOutUnit', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_14_CutOutUnit', _module_typeBindings.UnitsLength, unicode_default='nm')
    __CutOutUnit._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2352, 6)
    __CutOutUnit._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2352, 6)
    
    CutOutUnit = property(__CutOutUnit.value, __CutOutUnit.set, None, 'The units of the CutOut - default:nanometres[nm].')

    
    # Attribute CutInTolerance uses Python identifier CutInTolerance
    __CutInTolerance = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'CutInTolerance'), 'CutInTolerance', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_14_CutInTolerance', _module_typeBindings.NonNegativeFloat)
    __CutInTolerance._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2357, 6)
    __CutInTolerance._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2357, 6)
    
    CutInTolerance = property(__CutInTolerance.value, __CutInTolerance.set, None, '\n            CutInTolerance. Units are set by CutInToleranceUnit.\n          ')

    
    # Attribute CutInToleranceUnit uses Python identifier CutInToleranceUnit
    __CutInToleranceUnit = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'CutInToleranceUnit'), 'CutInToleranceUnit', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_14_CutInToleranceUnit', _module_typeBindings.UnitsLength, unicode_default='nm')
    __CutInToleranceUnit._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2364, 6)
    __CutInToleranceUnit._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2364, 6)
    
    CutInToleranceUnit = property(__CutInToleranceUnit.value, __CutInToleranceUnit.set, None, 'The units of the CutInTolerance - default:nanometres[nm].')

    
    # Attribute CutOutTolerance uses Python identifier CutOutTolerance
    __CutOutTolerance = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'CutOutTolerance'), 'CutOutTolerance', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_14_CutOutTolerance', _module_typeBindings.NonNegativeFloat)
    __CutOutTolerance._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2369, 6)
    __CutOutTolerance._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2369, 6)
    
    CutOutTolerance = property(__CutOutTolerance.value, __CutOutTolerance.set, None, '\n            CutOutTolerance. Units are set by CutOutToleranceUnit.\n          ')

    
    # Attribute CutOutToleranceUnit uses Python identifier CutOutToleranceUnit
    __CutOutToleranceUnit = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'CutOutToleranceUnit'), 'CutOutToleranceUnit', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_14_CutOutToleranceUnit', _module_typeBindings.UnitsLength, unicode_default='nm')
    __CutOutToleranceUnit._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2376, 6)
    __CutOutToleranceUnit._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2376, 6)
    
    CutOutToleranceUnit = property(__CutOutToleranceUnit.value, __CutOutToleranceUnit.set, None, 'The units of the CutOutTolerance - default:nanometres[nm].')

    
    # Attribute Transmittance uses Python identifier Transmittance
    __Transmittance = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'Transmittance'), 'Transmittance', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_14_Transmittance', _module_typeBindings.PercentFraction)
    __Transmittance._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2381, 6)
    __Transmittance._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2381, 6)
    
    Transmittance = property(__Transmittance.value, __Transmittance.set, None, '\n            The amount of light the filter transmits at a maximum [units:none]\n            A fraction, as a value from 0.0 to 1.0.\n          ')

    _ElementMap.update({
        
    })
    _AttributeMap.update({
        __CutIn.name() : __CutIn,
        __CutInUnit.name() : __CutInUnit,
        __CutOut.name() : __CutOut,
        __CutOutUnit.name() : __CutOutUnit,
        __CutInTolerance.name() : __CutInTolerance,
        __CutInToleranceUnit.name() : __CutInToleranceUnit,
        __CutOutTolerance.name() : __CutOutTolerance,
        __CutOutToleranceUnit.name() : __CutOutToleranceUnit,
        __Transmittance.name() : __Transmittance
    })
_module_typeBindings.CTD_ANON_14 = CTD_ANON_14


# Complex type {http://www.openmicroscopy.org/Schemas/OME/2016-06}Settings with content type EMPTY
class Settings (Reference):
    """
        Settings is an empty complex type that is contained and extended by all the *Settings elements
        Each *Settings element defines an attribute named ID of simple type *ID and the other information that is needed.
        Each simple type *ID is restricted to the base type LSID with an appropriate pattern
      """
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_EMPTY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'Settings')
    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2992, 2)
    _ElementMap = Reference._ElementMap.copy()
    _AttributeMap = Reference._AttributeMap.copy()
    # Base type is Reference
    _ElementMap.update({
        
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.Settings = Settings
Namespace.addCategoryObject('typeBinding', 'Settings', Settings)


# Complex type [anonymous] with content type EMPTY
class CTD_ANON_15 (pyxb.binding.basis.complexTypeDefinition):
    """Describes a file location.  Can optionally specify a portion of a file using Offset and a ReadLength.
      If Offset and ReadLength are specified in conjuction with Compression, then they point into the uncompressed file.
      """
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_EMPTY
    _Abstract = False
    _ExpandedName = None
    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3295, 4)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Attribute href uses Python identifier href
    __href = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'href'), 'href', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_15_href', pyxb.binding.datatypes.anyURI, required=True)
    __href._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3296, 6)
    __href._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3296, 6)
    
    href = property(__href.value, __href.set, None, 'file location')

    
    # Attribute SHA1 uses Python identifier SHA1
    __SHA1 = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'SHA1'), 'SHA1', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_15_SHA1', _module_typeBindings.Hex40, required=True)
    __SHA1._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3301, 6)
    __SHA1._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3301, 6)
    
    SHA1 = property(__SHA1.value, __SHA1.set, None, 'The digest of the file specified in href.')

    
    # Attribute Compression uses Python identifier Compression
    __Compression = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'Compression'), 'Compression', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_15_Compression', _module_typeBindings.STD_ANON_26, unicode_default='none')
    __Compression._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3306, 6)
    __Compression._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3306, 6)
    
    Compression = property(__Compression.value, __Compression.set, None, 'Specifies the compression scheme used to encode the data.')

    _ElementMap.update({
        
    })
    _AttributeMap.update({
        __href.name() : __href,
        __SHA1.name() : __SHA1,
        __Compression.name() : __Compression
    })
_module_typeBindings.CTD_ANON_15 = CTD_ANON_15


# Complex type [anonymous] with content type ELEMENT_ONLY
class CTD_ANON_16 (pyxb.binding.basis.complexTypeDefinition):
    """Describes a binary file."""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = None
    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3367, 4)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}External uses Python identifier External
    __External = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'External'), 'External', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_16_httpwww_openmicroscopy_orgSchemasOME2016_06External', False, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3288, 2), )

    
    External = property(__External.value, __External.set, None, 'Describes a file location.  Can optionally specify a portion of a file using Offset and a ReadLength.\n      If Offset and ReadLength are specified in conjuction with Compression, then they point into the uncompressed file.\n      ')

    
    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}BinData uses Python identifier BinData
    __BinData = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'BinData'), 'BinData', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_16_httpwww_openmicroscopy_orgSchemasOME2016_06BinData', False, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3320, 2), )

    
    BinData = property(__BinData.value, __BinData.set, None, 'The contents of this element are base64-encoded.  These are not CDATA sections, just a base64 stream.')

    
    # Attribute FileName uses Python identifier FileName
    __FileName = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'FileName'), 'FileName', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_16_FileName', pyxb.binding.datatypes.string, required=True)
    __FileName._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3372, 6)
    __FileName._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3372, 6)
    
    FileName = property(__FileName.value, __FileName.set, None, None)

    
    # Attribute Size uses Python identifier Size
    __Size = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'Size'), 'Size', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_16_Size', _module_typeBindings.NonNegativeLong, required=True)
    __Size._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3373, 6)
    __Size._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3373, 6)
    
    Size = property(__Size.value, __Size.set, None, '\n            Size of the uncompressed file. [unit:bytes]\n          ')

    
    # Attribute MIMEType uses Python identifier MIMEType
    __MIMEType = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'MIMEType'), 'MIMEType', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_16_MIMEType', pyxb.binding.datatypes.string)
    __MIMEType._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3380, 6)
    __MIMEType._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3380, 6)
    
    MIMEType = property(__MIMEType.value, __MIMEType.set, None, None)

    _ElementMap.update({
        __External.name() : __External,
        __BinData.name() : __BinData
    })
    _AttributeMap.update({
        __FileName.name() : __FileName,
        __Size.name() : __Size,
        __MIMEType.name() : __MIMEType
    })
_module_typeBindings.CTD_ANON_16 = CTD_ANON_16


# Complex type [anonymous] with content type ELEMENT_ONLY
class CTD_ANON_17 (pyxb.binding.basis.complexTypeDefinition):
    """
        This element describes the actual image and its meta-data.
        The elements that are references (ending in Ref or Settings) refer to
        elements defined outside of the Image element. Ref elements are simple
        links, while Settings elements are links with additional values.

        If any of the required Image attributes or elements are missing, its
        guaranteed to be an invalid document. The required attributes and
        elements are ID and Pixels.

        ExperimenterRef is required for all Images with well formed LSIDs.
        ImageType is a vendor-specific designation of the type of image this is.
        Examples of ImageType include 'STK', 'SoftWorx', etc.
        The Name attributes are in all cases the name of the element
        instance. In this case, the name of the image, not necessarily the filename.
        Physical size of pixels are microns[µm].
      """
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = None
    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 230, 4)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}AcquisitionDate uses Python identifier AcquisitionDate
    __AcquisitionDate = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'AcquisitionDate'), 'AcquisitionDate', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_17_httpwww_openmicroscopy_orgSchemasOME2016_06AcquisitionDate', False, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 232, 8), )

    
    AcquisitionDate = property(__AcquisitionDate.value, __AcquisitionDate.set, None, "\n              The acquisition date of the Image.\n              The element contains an xsd:dateTime string based on the ISO 8601 format (i.e. 1988-04-07T18:39:09.359)\n\n              YYYY-MM-DDTHH:mm:SS.sssZ\n              Y - Year\n              M - Month\n              D - Day\n              H - Hour\n              m - minutes\n              S - Seconds\n              s - sub-seconds (optional)\n              Z - Zone (optional) +HH:mm or -HH:mm or Z for UTC\n\n              Note: xsd:dataTime supports a very wide date range with unlimited precision. The full date range\n              and precision are not typically supported by platform- and language-specific libraries.\n              Where the supported time precision is less than the precision used by the xsd:dateTime\n              timestamp there will be loss of precision; this will typically occur via direct truncation\n              or (less commonly) rounding.\n\n              The year value can be large and/or negative. Any value covering the current or last century\n              should be correctly processed, but some systems cannot process earlier dates.\n\n              The sub-second value is defined as an unlimited number of digits after the decimal point.\n              In Java a minimum of millisecond precision is guaranteed.\n              In C++ microsecond precision is guaranteed, with nanosecond precision being available on\n              some platforms.\n\n              Time zones are supported, eg '2013-10-24T11:52:33+01:00' for Paris, but in most cases it will\n              be converted to UTC when the timestamp is written.\n            ")

    
    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}Description uses Python identifier Description
    __Description = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'Description'), 'Description', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_17_httpwww_openmicroscopy_orgSchemasOME2016_06Description', False, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 268, 8), )

    
    Description = property(__Description.value, __Description.set, None, '\n              A description for the image. [plain-text multi-line string]\n            ')

    
    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}Pixels uses Python identifier Pixels
    __Pixels = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'Pixels'), 'Pixels', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_17_httpwww_openmicroscopy_orgSchemasOME2016_06Pixels', False, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 307, 2), )

    
    Pixels = property(__Pixels.value, __Pixels.set, None, "\n        Pixels is going to be removed in the future, but it is still required.\n\n        This is just notice that the contents of Pixels will be\n        moved up to Image in a future release. This is because there\n        has only been 1 Pixels object in each Image for some time.\n        The concept of multiple Pixels sets for one Image failed to\n        take off. It is therefore redundant.\n\n        The Image will be unreadable if any of the required Pixel attributes are missing.\n\n        The Pixels themselves can be stored within the OME-XML compressed by plane, and encoded\n        in Base64.\n        Or the Pixels may be stored in TIFF format.\n\n        The Pixels element should contain a list of BinData or TiffData, each containing a\n        single plane of pixels. These Pixels elements, when read in document order,\n        must produce a 5-D pixel array of the size specified in this element, and in the\n        dimension order specified by 'DimensionOrder'.\n\n        All of the values in the Pixels object when present should match the same value\n        stored in any associated TIFF format (e.g. SizeX should be the same). Where there\n        is a mismatch our readers will take the value from the TIFF structure as overriding\n        the value in the OME-XML. This is simply a pragmatic decision as it increases the\n        likelihood of reading data from a slightly incorrect file.\n      ")

    
    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}StageLabel uses Python identifier StageLabel
    __StageLabel = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'StageLabel'), 'StageLabel', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_17_httpwww_openmicroscopy_orgSchemasOME2016_06StageLabel', False, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 871, 2), )

    
    StageLabel = property(__StageLabel.value, __StageLabel.set, None, "\n        The StageLabel is used to specify a name and position for a stage position in the microscope's reference frame.\n      ")

    
    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}ImagingEnvironment uses Python identifier ImagingEnvironment
    __ImagingEnvironment = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'ImagingEnvironment'), 'ImagingEnvironment', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_17_httpwww_openmicroscopy_orgSchemasOME2016_06ImagingEnvironment', False, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1041, 2), )

    
    ImagingEnvironment = property(__ImagingEnvironment.value, __ImagingEnvironment.set, None, '\n        This describes the environment that the biological sample was in\n        during the experiment.\n      ')

    
    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}MicrobeamManipulationRef uses Python identifier MicrobeamManipulationRef
    __MicrobeamManipulationRef = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'MicrobeamManipulationRef'), 'MicrobeamManipulationRef', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_17_httpwww_openmicroscopy_orgSchemasOME2016_06MicrobeamManipulationRef', True, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2867, 2), )

    
    MicrobeamManipulationRef = property(__MicrobeamManipulationRef.value, __MicrobeamManipulationRef.set, None, None)

    
    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}ExperimentRef uses Python identifier ExperimentRef
    __ExperimentRef = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'ExperimentRef'), 'ExperimentRef', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_17_httpwww_openmicroscopy_orgSchemasOME2016_06ExperimentRef', False, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2876, 2), )

    
    ExperimentRef = property(__ExperimentRef.value, __ExperimentRef.set, None, None)

    
    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}ExperimenterRef uses Python identifier ExperimenterRef
    __ExperimenterRef = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'ExperimenterRef'), 'ExperimenterRef', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_17_httpwww_openmicroscopy_orgSchemasOME2016_06ExperimenterRef', False, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2909, 2), )

    
    ExperimenterRef = property(__ExperimenterRef.value, __ExperimenterRef.set, None, '\n        This empty element has a required Experimenter ID and an optional DocumentID attribute which refers to one of the Experimenters defined within OME.\n      ')

    
    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}ExperimenterGroupRef uses Python identifier ExperimenterGroupRef
    __ExperimenterGroupRef = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'ExperimenterGroupRef'), 'ExperimenterGroupRef', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_17_httpwww_openmicroscopy_orgSchemasOME2016_06ExperimenterGroupRef', False, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2923, 2), )

    
    ExperimenterGroupRef = property(__ExperimenterGroupRef.value, __ExperimenterGroupRef.set, None, 'This empty element has a reference (the ExperimenterGroup ID attribute) to a ExperimenterGroup defined within OME.')

    
    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}InstrumentRef uses Python identifier InstrumentRef
    __InstrumentRef = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'InstrumentRef'), 'InstrumentRef', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_17_httpwww_openmicroscopy_orgSchemasOME2016_06InstrumentRef', False, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2935, 2), )

    
    InstrumentRef = property(__InstrumentRef.value, __InstrumentRef.set, None, '\n        This empty element can be used (via the required Instrument ID attribute) to refer to an Instrument defined within OME.\n      ')

    
    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}ObjectiveSettings uses Python identifier ObjectiveSettings
    __ObjectiveSettings = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'ObjectiveSettings'), 'ObjectiveSettings', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_17_httpwww_openmicroscopy_orgSchemasOME2016_06ObjectiveSettings', False, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3129, 2), )

    
    ObjectiveSettings = property(__ObjectiveSettings.value, __ObjectiveSettings.set, None, '\n        This holds the setting applied to an objective as well as a\n        reference to the objective.\n        The ID is the objective used in this case.\n      ')

    
    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}AnnotationRef uses Python identifier AnnotationRef
    __AnnotationRef = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'AnnotationRef'), 'AnnotationRef', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_17_httpwww_openmicroscopy_orgSchemasOME2016_06AnnotationRef', True, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3435, 2), )

    
    AnnotationRef = property(__AnnotationRef.value, __AnnotationRef.set, None, '\n        The AnnotationRef element is a reference to an element derived\n        from the CommonAnnotation element.\n      ')

    
    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}ROIRef uses Python identifier ROIRef
    __ROIRef = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'ROIRef'), 'ROIRef', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_17_httpwww_openmicroscopy_orgSchemasOME2016_06ROIRef', True, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4247, 2), )

    
    ROIRef = property(__ROIRef.value, __ROIRef.set, None, None)

    
    # Attribute ID uses Python identifier ID
    __ID = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'ID'), 'ID', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_17_ID', _module_typeBindings.ImageID, required=True)
    __ID._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 303, 6)
    __ID._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 303, 6)
    
    ID = property(__ID.value, __ID.set, None, None)

    
    # Attribute Name uses Python identifier Name
    __Name = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'Name'), 'Name', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_17_Name', pyxb.binding.datatypes.string)
    __Name._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 304, 6)
    __Name._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 304, 6)
    
    Name = property(__Name.value, __Name.set, None, None)

    _ElementMap.update({
        __AcquisitionDate.name() : __AcquisitionDate,
        __Description.name() : __Description,
        __Pixels.name() : __Pixels,
        __StageLabel.name() : __StageLabel,
        __ImagingEnvironment.name() : __ImagingEnvironment,
        __MicrobeamManipulationRef.name() : __MicrobeamManipulationRef,
        __ExperimentRef.name() : __ExperimentRef,
        __ExperimenterRef.name() : __ExperimenterRef,
        __ExperimenterGroupRef.name() : __ExperimenterGroupRef,
        __InstrumentRef.name() : __InstrumentRef,
        __ObjectiveSettings.name() : __ObjectiveSettings,
        __AnnotationRef.name() : __AnnotationRef,
        __ROIRef.name() : __ROIRef
    })
    _AttributeMap.update({
        __ID.name() : __ID,
        __Name.name() : __Name
    })
_module_typeBindings.CTD_ANON_17 = CTD_ANON_17


# Complex type [anonymous] with content type ELEMENT_ONLY
class CTD_ANON_18 (pyxb.binding.basis.complexTypeDefinition):
    """
        Pixels is going to be removed in the future, but it is still required.

        This is just notice that the contents of Pixels will be
        moved up to Image in a future release. This is because there
        has only been 1 Pixels object in each Image for some time.
        The concept of multiple Pixels sets for one Image failed to
        take off. It is therefore redundant.

        The Image will be unreadable if any of the required Pixel attributes are missing.

        The Pixels themselves can be stored within the OME-XML compressed by plane, and encoded
        in Base64.
        Or the Pixels may be stored in TIFF format.

        The Pixels element should contain a list of BinData or TiffData, each containing a
        single plane of pixels. These Pixels elements, when read in document order,
        must produce a 5-D pixel array of the size specified in this element, and in the
        dimension order specified by 'DimensionOrder'.

        All of the values in the Pixels object when present should match the same value
        stored in any associated TIFF format (e.g. SizeX should be the same). Where there
        is a mismatch our readers will take the value from the TIFF structure as overriding
        the value in the OME-XML. This is simply a pragmatic decision as it increases the
        likelihood of reading data from a slightly incorrect file.
      """
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = None
    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 337, 4)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}Plane uses Python identifier Plane
    __Plane = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'Plane'), 'Plane', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_18_httpwww_openmicroscopy_orgSchemasOME2016_06Plane', True, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 478, 2), )

    
    Plane = property(__Plane.value, __Plane.set, None, '\n        The Plane object holds microscope stage and image timing data\n        for a given channel/z-section/timepoint.\n      ')

    
    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}Channel uses Python identifier Channel
    __Channel = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'Channel'), 'Channel', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_18_httpwww_openmicroscopy_orgSchemasOME2016_06Channel', True, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 592, 2), )

    
    Channel = property(__Channel.value, __Channel.set, None, "\n        There must be one per channel in the Image, even for a single-plane image.\n        And information about how each of them was acquired is stored in the various optional *Ref elements.  Each Logical Channel is composed of one or more\n        ChannelComponents.  For example, an entire spectrum in an FTIR experiment may be stored in a single Logical Channel with each discrete wavenumber of the spectrum\n        constituting a ChannelComponent of the FTIR Logical Channel.  An RGB image where the Red, Green and Blue components do not reflect discrete probes but are\n        instead the output of a color camera would be treated similarly - one Logical channel with three ChannelComponents in this case.\n        The total number of ChannelComponents for a set of pixels must equal SizeC.\n        The IlluminationType attribute is a string enumeration which may be set to 'Transmitted', 'Epifluorescence', 'Oblique', or 'NonLinear'.\n        The user interface logic for labeling a given channel for the user should use the first existing attribute in the following sequence:\n        Name -> Fluor -> EmissionWavelength -> ChannelComponent/Index.\n      ")

    
    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}MetadataOnly uses Python identifier MetadataOnly
    __MetadataOnly = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'MetadataOnly'), 'MetadataOnly', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_18_httpwww_openmicroscopy_orgSchemasOME2016_06MetadataOnly', False, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 784, 2), )

    
    MetadataOnly = property(__MetadataOnly.value, __MetadataOnly.set, None, '\n        This place holder means there is on pixel data in this file.\n      ')

    
    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}TiffData uses Python identifier TiffData
    __TiffData = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'TiffData'), 'TiffData', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_18_httpwww_openmicroscopy_orgSchemasOME2016_06TiffData', True, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 792, 2), )

    
    TiffData = property(__TiffData.value, __TiffData.set, None, '\n        This described the location of the pixel data in a tiff file.\n      ')

    
    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}BinData uses Python identifier BinData
    __BinData = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'BinData'), 'BinData', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_18_httpwww_openmicroscopy_orgSchemasOME2016_06BinData', True, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3320, 2), )

    
    BinData = property(__BinData.value, __BinData.set, None, 'The contents of this element are base64-encoded.  These are not CDATA sections, just a base64 stream.')

    
    # Attribute ID uses Python identifier ID
    __ID = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'ID'), 'ID', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_18_ID', _module_typeBindings.PixelsID, required=True)
    __ID._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 351, 6)
    __ID._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 351, 6)
    
    ID = property(__ID.value, __ID.set, None, None)

    
    # Attribute DimensionOrder uses Python identifier DimensionOrder
    __DimensionOrder = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'DimensionOrder'), 'DimensionOrder', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_18_DimensionOrder', _module_typeBindings.STD_ANON_, required=True)
    __DimensionOrder._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 352, 6)
    __DimensionOrder._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 352, 6)
    
    DimensionOrder = property(__DimensionOrder.value, __DimensionOrder.set, None, '\n            The order in which the individual planes of data are interleaved.\n          ')

    
    # Attribute Type uses Python identifier Type
    __Type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'Type'), 'Type', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_18_Type', _module_typeBindings.PixelType, required=True)
    __Type._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 369, 6)
    __Type._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 369, 6)
    
    Type = property(__Type.value, __Type.set, None, '\n            The variable type used to represent each pixel in the image.\n          ')

    
    # Attribute SignificantBits uses Python identifier SignificantBits
    __SignificantBits = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'SignificantBits'), 'SignificantBits', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_18_SignificantBits', _module_typeBindings.PositiveInt)
    __SignificantBits._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 376, 6)
    __SignificantBits._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 376, 6)
    
    SignificantBits = property(__SignificantBits.value, __SignificantBits.set, None, '\n            The number of bits within the type storing each pixel that are significant.\n            e.g. you can store 12 bit data within a 16 bit type.\n            This does not reduce the storage requirements but can be a useful indicator\n            when processing or viewing the image data.\n          ')

    
    # Attribute Interleaved uses Python identifier Interleaved
    __Interleaved = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'Interleaved'), 'Interleaved', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_18_Interleaved', pyxb.binding.datatypes.boolean)
    __Interleaved._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 386, 6)
    __Interleaved._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 386, 6)
    
    Interleaved = property(__Interleaved.value, __Interleaved.set, None, '\n            How the channels are arranged within the data block:\n            true if channels are stored RGBRGBRGB...;\n            false if channels are stored RRR...GGG...BBB...\n          ')

    
    # Attribute BigEndian uses Python identifier BigEndian
    __BigEndian = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'BigEndian'), 'BigEndian', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_18_BigEndian', pyxb.binding.datatypes.boolean)
    __BigEndian._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 395, 6)
    __BigEndian._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 395, 6)
    
    BigEndian = property(__BigEndian.value, __BigEndian.set, None, '\n            This is true if the pixels data was written in BigEndian order.\n\n            If this value is present it should match the value used in BinData\n            or TiffData. If it does not a reader should honour the value used\n            in the BinData or TiffData. This values is useful for MetadataOnly\n            files and is to allow for future storage solutions.\n          ')

    
    # Attribute SizeX uses Python identifier SizeX
    __SizeX = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'SizeX'), 'SizeX', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_18_SizeX', _module_typeBindings.PositiveInt, required=True)
    __SizeX._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 407, 6)
    __SizeX._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 407, 6)
    
    SizeX = property(__SizeX.value, __SizeX.set, None, 'Dimensional size of pixel data array [units:none]')

    
    # Attribute SizeY uses Python identifier SizeY
    __SizeY = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'SizeY'), 'SizeY', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_18_SizeY', _module_typeBindings.PositiveInt, required=True)
    __SizeY._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 412, 6)
    __SizeY._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 412, 6)
    
    SizeY = property(__SizeY.value, __SizeY.set, None, 'Dimensional size of pixel data array [units:none]')

    
    # Attribute SizeZ uses Python identifier SizeZ
    __SizeZ = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'SizeZ'), 'SizeZ', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_18_SizeZ', _module_typeBindings.PositiveInt, required=True)
    __SizeZ._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 417, 6)
    __SizeZ._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 417, 6)
    
    SizeZ = property(__SizeZ.value, __SizeZ.set, None, 'Dimensional size of pixel data array [units:none]')

    
    # Attribute SizeC uses Python identifier SizeC
    __SizeC = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'SizeC'), 'SizeC', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_18_SizeC', _module_typeBindings.PositiveInt, required=True)
    __SizeC._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 422, 6)
    __SizeC._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 422, 6)
    
    SizeC = property(__SizeC.value, __SizeC.set, None, 'Dimensional size of pixel data array [units:none]')

    
    # Attribute SizeT uses Python identifier SizeT
    __SizeT = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'SizeT'), 'SizeT', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_18_SizeT', _module_typeBindings.PositiveInt, required=True)
    __SizeT._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 427, 6)
    __SizeT._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 427, 6)
    
    SizeT = property(__SizeT.value, __SizeT.set, None, 'Dimensional size of pixel data array [units:none]')

    
    # Attribute PhysicalSizeX uses Python identifier PhysicalSizeX
    __PhysicalSizeX = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'PhysicalSizeX'), 'PhysicalSizeX', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_18_PhysicalSizeX', _module_typeBindings.PositiveFloat)
    __PhysicalSizeX._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 432, 6)
    __PhysicalSizeX._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 432, 6)
    
    PhysicalSizeX = property(__PhysicalSizeX.value, __PhysicalSizeX.set, None, 'Physical size of a pixel. Units are set by PhysicalSizeXUnit.')

    
    # Attribute PhysicalSizeXUnit uses Python identifier PhysicalSizeXUnit
    __PhysicalSizeXUnit = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'PhysicalSizeXUnit'), 'PhysicalSizeXUnit', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_18_PhysicalSizeXUnit', _module_typeBindings.UnitsLength, unicode_default='\xb5m')
    __PhysicalSizeXUnit._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 437, 6)
    __PhysicalSizeXUnit._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 437, 6)
    
    PhysicalSizeXUnit = property(__PhysicalSizeXUnit.value, __PhysicalSizeXUnit.set, None, 'The units of the physical size of a pixel - default:microns[\xb5m].')

    
    # Attribute PhysicalSizeY uses Python identifier PhysicalSizeY
    __PhysicalSizeY = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'PhysicalSizeY'), 'PhysicalSizeY', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_18_PhysicalSizeY', _module_typeBindings.PositiveFloat)
    __PhysicalSizeY._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 442, 6)
    __PhysicalSizeY._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 442, 6)
    
    PhysicalSizeY = property(__PhysicalSizeY.value, __PhysicalSizeY.set, None, 'Physical size of a pixel. Units are set by PhysicalSizeYUnit.')

    
    # Attribute PhysicalSizeYUnit uses Python identifier PhysicalSizeYUnit
    __PhysicalSizeYUnit = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'PhysicalSizeYUnit'), 'PhysicalSizeYUnit', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_18_PhysicalSizeYUnit', _module_typeBindings.UnitsLength, unicode_default='\xb5m')
    __PhysicalSizeYUnit._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 447, 6)
    __PhysicalSizeYUnit._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 447, 6)
    
    PhysicalSizeYUnit = property(__PhysicalSizeYUnit.value, __PhysicalSizeYUnit.set, None, 'The units of the physical size of a pixel - default:microns[\xb5m].')

    
    # Attribute PhysicalSizeZ uses Python identifier PhysicalSizeZ
    __PhysicalSizeZ = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'PhysicalSizeZ'), 'PhysicalSizeZ', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_18_PhysicalSizeZ', _module_typeBindings.PositiveFloat)
    __PhysicalSizeZ._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 452, 6)
    __PhysicalSizeZ._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 452, 6)
    
    PhysicalSizeZ = property(__PhysicalSizeZ.value, __PhysicalSizeZ.set, None, 'Physical size of a pixel. Units are set by PhysicalSizeZUnit.')

    
    # Attribute PhysicalSizeZUnit uses Python identifier PhysicalSizeZUnit
    __PhysicalSizeZUnit = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'PhysicalSizeZUnit'), 'PhysicalSizeZUnit', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_18_PhysicalSizeZUnit', _module_typeBindings.UnitsLength, unicode_default='\xb5m')
    __PhysicalSizeZUnit._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 457, 6)
    __PhysicalSizeZUnit._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 457, 6)
    
    PhysicalSizeZUnit = property(__PhysicalSizeZUnit.value, __PhysicalSizeZUnit.set, None, 'The units of the physical size of a pixel - default:microns[\xb5m].')

    
    # Attribute TimeIncrement uses Python identifier TimeIncrement
    __TimeIncrement = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'TimeIncrement'), 'TimeIncrement', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_18_TimeIncrement', pyxb.binding.datatypes.float)
    __TimeIncrement._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 462, 6)
    __TimeIncrement._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 462, 6)
    
    TimeIncrement = property(__TimeIncrement.value, __TimeIncrement.set, None, '\n            TimeIncrement is used for time series that have a global\n            timing specification instead of per-timepoint timing info.\n            For example in a video stream. Units are set by TimeIncrementUnit.\n          ')

    
    # Attribute TimeIncrementUnit uses Python identifier TimeIncrementUnit
    __TimeIncrementUnit = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'TimeIncrementUnit'), 'TimeIncrementUnit', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_18_TimeIncrementUnit', _module_typeBindings.UnitsTime, unicode_default='s')
    __TimeIncrementUnit._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 471, 6)
    __TimeIncrementUnit._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 471, 6)
    
    TimeIncrementUnit = property(__TimeIncrementUnit.value, __TimeIncrementUnit.set, None, 'The units of the TimeIncrement - default:seconds[s].')

    _ElementMap.update({
        __Plane.name() : __Plane,
        __Channel.name() : __Channel,
        __MetadataOnly.name() : __MetadataOnly,
        __TiffData.name() : __TiffData,
        __BinData.name() : __BinData
    })
    _AttributeMap.update({
        __ID.name() : __ID,
        __DimensionOrder.name() : __DimensionOrder,
        __Type.name() : __Type,
        __SignificantBits.name() : __SignificantBits,
        __Interleaved.name() : __Interleaved,
        __BigEndian.name() : __BigEndian,
        __SizeX.name() : __SizeX,
        __SizeY.name() : __SizeY,
        __SizeZ.name() : __SizeZ,
        __SizeC.name() : __SizeC,
        __SizeT.name() : __SizeT,
        __PhysicalSizeX.name() : __PhysicalSizeX,
        __PhysicalSizeXUnit.name() : __PhysicalSizeXUnit,
        __PhysicalSizeY.name() : __PhysicalSizeY,
        __PhysicalSizeYUnit.name() : __PhysicalSizeYUnit,
        __PhysicalSizeZ.name() : __PhysicalSizeZ,
        __PhysicalSizeZUnit.name() : __PhysicalSizeZUnit,
        __TimeIncrement.name() : __TimeIncrement,
        __TimeIncrementUnit.name() : __TimeIncrementUnit
    })
_module_typeBindings.CTD_ANON_18 = CTD_ANON_18


# Complex type [anonymous] with content type ELEMENT_ONLY
class CTD_ANON_19 (pyxb.binding.basis.complexTypeDefinition):
    """
        There must be one per channel in the Image, even for a single-plane image.
        And information about how each of them was acquired is stored in the various optional *Ref elements.  Each Logical Channel is composed of one or more
        ChannelComponents.  For example, an entire spectrum in an FTIR experiment may be stored in a single Logical Channel with each discrete wavenumber of the spectrum
        constituting a ChannelComponent of the FTIR Logical Channel.  An RGB image where the Red, Green and Blue components do not reflect discrete probes but are
        instead the output of a color camera would be treated similarly - one Logical channel with three ChannelComponents in this case.
        The total number of ChannelComponents for a set of pixels must equal SizeC.
        The IlluminationType attribute is a string enumeration which may be set to 'Transmitted', 'Epifluorescence', 'Oblique', or 'NonLinear'.
        The user interface logic for labeling a given channel for the user should use the first existing attribute in the following sequence:
        Name -> Fluor -> EmissionWavelength -> ChannelComponent/Index.
      """
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = None
    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 607, 4)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}LightPath uses Python identifier LightPath
    __LightPath = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'LightPath'), 'LightPath', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_19_httpwww_openmicroscopy_orgSchemasOME2016_06LightPath', False, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2411, 2), )

    
    LightPath = property(__LightPath.value, __LightPath.set, None, 'A description of the light path')

    
    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}FilterSetRef uses Python identifier FilterSetRef
    __FilterSetRef = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'FilterSetRef'), 'FilterSetRef', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_19_httpwww_openmicroscopy_orgSchemasOME2016_06FilterSetRef', False, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2981, 2), )

    
    FilterSetRef = property(__FilterSetRef.value, __FilterSetRef.set, None, None)

    
    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}LightSourceSettings uses Python identifier LightSourceSettings
    __LightSourceSettings = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'LightSourceSettings'), 'LightSourceSettings', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_19_httpwww_openmicroscopy_orgSchemasOME2016_06LightSourceSettings', False, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3006, 2), )

    
    LightSourceSettings = property(__LightSourceSettings.value, __LightSourceSettings.set, None, '')

    
    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}DetectorSettings uses Python identifier DetectorSettings
    __DetectorSettings = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'DetectorSettings'), 'DetectorSettings', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_19_httpwww_openmicroscopy_orgSchemasOME2016_06DetectorSettings', False, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3040, 2), )

    
    DetectorSettings = property(__DetectorSettings.value, __DetectorSettings.set, None, '\n        This holds the setting applied to a detector as well as a\n        reference to the detector.\n        The ID is the detector used in this case.\n        The values stored in DetectorSettings represent the variable values,\n        fixed values not modified during the acquisition go in Detector.\n\n        Each attribute now has an indication of what type of detector\n        it applies to. This is preparatory work for cleaning up and\n        possibly splitting this object into sub-types.\n      ')

    
    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}AnnotationRef uses Python identifier AnnotationRef
    __AnnotationRef = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'AnnotationRef'), 'AnnotationRef', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_19_httpwww_openmicroscopy_orgSchemasOME2016_06AnnotationRef', True, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3435, 2), )

    
    AnnotationRef = property(__AnnotationRef.value, __AnnotationRef.set, None, '\n        The AnnotationRef element is a reference to an element derived\n        from the CommonAnnotation element.\n      ')

    
    # Attribute ID uses Python identifier ID
    __ID = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'ID'), 'ID', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_19_ID', _module_typeBindings.ChannelID, required=True)
    __ID._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 619, 6)
    __ID._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 619, 6)
    
    ID = property(__ID.value, __ID.set, None, None)

    
    # Attribute Name uses Python identifier Name
    __Name = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'Name'), 'Name', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_19_Name', pyxb.binding.datatypes.string)
    __Name._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 620, 6)
    __Name._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 620, 6)
    
    Name = property(__Name.value, __Name.set, None, '\n            A name for the channel that is suitable for presentation to the user.\n          ')

    
    # Attribute SamplesPerPixel uses Python identifier SamplesPerPixel
    __SamplesPerPixel = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'SamplesPerPixel'), 'SamplesPerPixel', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_19_SamplesPerPixel', _module_typeBindings.PositiveInt)
    __SamplesPerPixel._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 627, 6)
    __SamplesPerPixel._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 627, 6)
    
    SamplesPerPixel = property(__SamplesPerPixel.value, __SamplesPerPixel.set, None, '\n            The number of samples the detector takes to form each pixel value. [units:none]\n            Note: This is not the same as "Frame Averaging" - see Integration in DetectorSettings\n          ')

    
    # Attribute IlluminationType uses Python identifier IlluminationType
    __IlluminationType = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'IlluminationType'), 'IlluminationType', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_19_IlluminationType', _module_typeBindings.STD_ANON_2)
    __IlluminationType._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 635, 6)
    __IlluminationType._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 635, 6)
    
    IlluminationType = property(__IlluminationType.value, __IlluminationType.set, None, '\n            The method of illumination used to capture the channel.\n          ')

    
    # Attribute PinholeSize uses Python identifier PinholeSize
    __PinholeSize = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'PinholeSize'), 'PinholeSize', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_19_PinholeSize', pyxb.binding.datatypes.float)
    __PinholeSize._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 651, 6)
    __PinholeSize._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 651, 6)
    
    PinholeSize = property(__PinholeSize.value, __PinholeSize.set, None, '\n            The optional PinholeSize attribute allows specifying adjustable\n            pin hole diameters for confocal microscopes. Units are set by PinholeSizeUnit.\n          ')

    
    # Attribute PinholeSizeUnit uses Python identifier PinholeSizeUnit
    __PinholeSizeUnit = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'PinholeSizeUnit'), 'PinholeSizeUnit', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_19_PinholeSizeUnit', _module_typeBindings.UnitsLength, unicode_default='\xb5m')
    __PinholeSizeUnit._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 659, 6)
    __PinholeSizeUnit._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 659, 6)
    
    PinholeSizeUnit = property(__PinholeSizeUnit.value, __PinholeSizeUnit.set, None, 'The units of the pin hole diameter for confocal microscopes - default:microns[\xb5m].')

    
    # Attribute AcquisitionMode uses Python identifier AcquisitionMode
    __AcquisitionMode = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'AcquisitionMode'), 'AcquisitionMode', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_19_AcquisitionMode', _module_typeBindings.STD_ANON_3)
    __AcquisitionMode._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 664, 6)
    __AcquisitionMode._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 664, 6)
    
    AcquisitionMode = property(__AcquisitionMode.value, __AcquisitionMode.set, None, '\n            AcquisitionMode describes the type of microscopy performed for each channel\n          ')

    
    # Attribute ContrastMethod uses Python identifier ContrastMethod
    __ContrastMethod = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'ContrastMethod'), 'ContrastMethod', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_19_ContrastMethod', _module_typeBindings.STD_ANON_4)
    __ContrastMethod._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 698, 6)
    __ContrastMethod._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 698, 6)
    
    ContrastMethod = property(__ContrastMethod.value, __ContrastMethod.set, None, '\n            ContrastMethod describes the technique used to achieve contrast for each channel\n          ')

    
    # Attribute ExcitationWavelength uses Python identifier ExcitationWavelength
    __ExcitationWavelength = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'ExcitationWavelength'), 'ExcitationWavelength', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_19_ExcitationWavelength', _module_typeBindings.PositiveFloat)
    __ExcitationWavelength._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 718, 6)
    __ExcitationWavelength._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 718, 6)
    
    ExcitationWavelength = property(__ExcitationWavelength.value, __ExcitationWavelength.set, None, '\n            Wavelength of excitation for a particular channel. Units are set by ExcitationWavelengthUnit.\n          ')

    
    # Attribute ExcitationWavelengthUnit uses Python identifier ExcitationWavelengthUnit
    __ExcitationWavelengthUnit = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'ExcitationWavelengthUnit'), 'ExcitationWavelengthUnit', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_19_ExcitationWavelengthUnit', _module_typeBindings.UnitsLength, unicode_default='nm')
    __ExcitationWavelengthUnit._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 725, 6)
    __ExcitationWavelengthUnit._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 725, 6)
    
    ExcitationWavelengthUnit = property(__ExcitationWavelengthUnit.value, __ExcitationWavelengthUnit.set, None, 'The units of the wavelength of excitation - default:nanometres[nm].')

    
    # Attribute EmissionWavelength uses Python identifier EmissionWavelength
    __EmissionWavelength = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'EmissionWavelength'), 'EmissionWavelength', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_19_EmissionWavelength', _module_typeBindings.PositiveFloat)
    __EmissionWavelength._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 730, 6)
    __EmissionWavelength._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 730, 6)
    
    EmissionWavelength = property(__EmissionWavelength.value, __EmissionWavelength.set, None, '\n            Wavelength of emission for a particular channel. Units are set by EmissionWavelengthUnit.\n          ')

    
    # Attribute EmissionWavelengthUnit uses Python identifier EmissionWavelengthUnit
    __EmissionWavelengthUnit = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'EmissionWavelengthUnit'), 'EmissionWavelengthUnit', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_19_EmissionWavelengthUnit', _module_typeBindings.UnitsLength, unicode_default='nm')
    __EmissionWavelengthUnit._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 737, 6)
    __EmissionWavelengthUnit._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 737, 6)
    
    EmissionWavelengthUnit = property(__EmissionWavelengthUnit.value, __EmissionWavelengthUnit.set, None, 'The units of the wavelength of emission - default:nanometres[nm].')

    
    # Attribute Fluor uses Python identifier Fluor
    __Fluor = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'Fluor'), 'Fluor', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_19_Fluor', pyxb.binding.datatypes.string)
    __Fluor._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 742, 6)
    __Fluor._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 742, 6)
    
    Fluor = property(__Fluor.value, __Fluor.set, None, '\n            The Fluor attribute is used for fluorescence images.\n            This is the name of the fluorophore used to produce this channel [plain text string]\n          ')

    
    # Attribute NDFilter uses Python identifier NDFilter
    __NDFilter = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'NDFilter'), 'NDFilter', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_19_NDFilter', pyxb.binding.datatypes.float)
    __NDFilter._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 750, 6)
    __NDFilter._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 750, 6)
    
    NDFilter = property(__NDFilter.value, __NDFilter.set, None, '\n            The NDfilter attribute is used to specify the combined effect of any neutral density filters used.\n            The amount of light the filter transmits at a maximum [units:none]\n            A fraction, as a value from 0.0 to 1.0.\n\n            NOTE: This was formerly described as "units optical density expressed as a PercentFraction".\n            This was how the field had been described in the schema from the beginning but all\n            the use of it has been in the opposite direction, i.e. as a amount transmitted,\n            not the amount blocked. This change has been made to make the model reflect this usage.\n          ')

    
    # Attribute PockelCellSetting uses Python identifier PockelCellSetting
    __PockelCellSetting = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'PockelCellSetting'), 'PockelCellSetting', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_19_PockelCellSetting', pyxb.binding.datatypes.int)
    __PockelCellSetting._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 764, 6)
    __PockelCellSetting._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 764, 6)
    
    PockelCellSetting = property(__PockelCellSetting.value, __PockelCellSetting.set, None, '\n            The PockelCellSetting used for this channel. This is the amount the polarization of the beam is rotated by. [units:none]\n          ')

    
    # Attribute Color uses Python identifier Color
    __Color = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'Color'), 'Color', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_19_Color', _module_typeBindings.Color, unicode_default='-1')
    __Color._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 771, 6)
    __Color._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 771, 6)
    
    Color = property(__Color.value, __Color.set, None, '\n            A color used to render this channel - encoded as RGBA\n            The default value "-1" is #FFFFFFFF so solid white (it is a signed 32 bit value)\n            NOTE: Prior to the 2012-06 schema the default value was incorrect and produced a transparent red not solid white.\n          ')

    _ElementMap.update({
        __LightPath.name() : __LightPath,
        __FilterSetRef.name() : __FilterSetRef,
        __LightSourceSettings.name() : __LightSourceSettings,
        __DetectorSettings.name() : __DetectorSettings,
        __AnnotationRef.name() : __AnnotationRef
    })
    _AttributeMap.update({
        __ID.name() : __ID,
        __Name.name() : __Name,
        __SamplesPerPixel.name() : __SamplesPerPixel,
        __IlluminationType.name() : __IlluminationType,
        __PinholeSize.name() : __PinholeSize,
        __PinholeSizeUnit.name() : __PinholeSizeUnit,
        __AcquisitionMode.name() : __AcquisitionMode,
        __ContrastMethod.name() : __ContrastMethod,
        __ExcitationWavelength.name() : __ExcitationWavelength,
        __ExcitationWavelengthUnit.name() : __ExcitationWavelengthUnit,
        __EmissionWavelength.name() : __EmissionWavelength,
        __EmissionWavelengthUnit.name() : __EmissionWavelengthUnit,
        __Fluor.name() : __Fluor,
        __NDFilter.name() : __NDFilter,
        __PockelCellSetting.name() : __PockelCellSetting,
        __Color.name() : __Color
    })
_module_typeBindings.CTD_ANON_19 = CTD_ANON_19


# Complex type [anonymous] with content type ELEMENT_ONLY
class CTD_ANON_20 (pyxb.binding.basis.complexTypeDefinition):
    """
        Defines a microbeam operation type and the region of the image it was applied to.
        The LightSourceRef element is a reference to a LightSource specified in the Instrument element which was used for a technique other than illumination for
        the purpose of imaging. For example, a laser used for photobleaching.
      """
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = None
    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 929, 4)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}Description uses Python identifier Description
    __Description = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'Description'), 'Description', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_20_httpwww_openmicroscopy_orgSchemasOME2016_06Description', False, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 931, 8), )

    
    Description = property(__Description.value, __Description.set, None, '\n              A description for the Microbeam Manipulation. [plain-text multi-line string]\n            ')

    
    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}ExperimenterRef uses Python identifier ExperimenterRef
    __ExperimenterRef = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'ExperimenterRef'), 'ExperimenterRef', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_20_httpwww_openmicroscopy_orgSchemasOME2016_06ExperimenterRef', False, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2909, 2), )

    
    ExperimenterRef = property(__ExperimenterRef.value, __ExperimenterRef.set, None, '\n        This empty element has a required Experimenter ID and an optional DocumentID attribute which refers to one of the Experimenters defined within OME.\n      ')

    
    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}LightSourceSettings uses Python identifier LightSourceSettings
    __LightSourceSettings = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'LightSourceSettings'), 'LightSourceSettings', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_20_httpwww_openmicroscopy_orgSchemasOME2016_06LightSourceSettings', True, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3006, 2), )

    
    LightSourceSettings = property(__LightSourceSettings.value, __LightSourceSettings.set, None, '')

    
    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}ROIRef uses Python identifier ROIRef
    __ROIRef = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'ROIRef'), 'ROIRef', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_20_httpwww_openmicroscopy_orgSchemasOME2016_06ROIRef', True, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4247, 2), )

    
    ROIRef = property(__ROIRef.value, __ROIRef.set, None, None)

    
    # Attribute ID uses Python identifier ID
    __ID = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'ID'), 'ID', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_20_ID', _module_typeBindings.MicrobeamManipulationID, required=True)
    __ID._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 951, 6)
    __ID._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 951, 6)
    
    ID = property(__ID.value, __ID.set, None, None)

    
    # Attribute Type uses Python identifier Type
    __Type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'Type'), 'Type', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_20_Type', _module_typeBindings.STD_ANON_37)
    __Type._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 952, 6)
    __Type._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 952, 6)
    
    Type = property(__Type.value, __Type.set, None, '\n            The type of manipulation performed.\n          ')

    _ElementMap.update({
        __Description.name() : __Description,
        __ExperimenterRef.name() : __ExperimenterRef,
        __LightSourceSettings.name() : __LightSourceSettings,
        __ROIRef.name() : __ROIRef
    })
    _AttributeMap.update({
        __ID.name() : __ID,
        __Type.name() : __Type
    })
_module_typeBindings.CTD_ANON_20 = CTD_ANON_20


# Complex type [anonymous] with content type ELEMENT_ONLY
class CTD_ANON_21 (pyxb.binding.basis.complexTypeDefinition):
    """
        This element describes the instrument used to capture the Image.
        It is primarily a container for manufacturer's model and catalog
        numbers for the Microscope, LightSource, Detector, Objective and
        Filters components.
        The Objective element contains the additional elements LensNA and Magnification.
        The Filters element can be composed either of separate excitation,
        emission filters and a dichroic mirror or a single filter set.
        Within the Image itself, a reference is made to this one Filter element.
        There may be multiple light sources, detectors, objectives and filters on a microscope.
        Each of these has their own ID attribute, which can be referred to from Channel.
        It is understood that the light path configuration can be different
        for each channel, but cannot be different for each timepoint or
        each plane of an XYZ stack.
      """
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = None
    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 998, 4)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}Microscope uses Python identifier Microscope
    __Microscope = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'Microscope'), 'Microscope', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_21_httpwww_openmicroscopy_orgSchemasOME2016_06Microscope', False, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1016, 2), )

    
    Microscope = property(__Microscope.value, __Microscope.set, None, "The microscope's manufacturer specification.")

    
    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}Objective uses Python identifier Objective
    __Objective = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'Objective'), 'Objective', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_21_httpwww_openmicroscopy_orgSchemasOME2016_06Objective', True, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2024, 2), )

    
    Objective = property(__Objective.value, __Objective.set, None, "\n        A description of the microscope's objective lens.\n        Required elements include the lens numerical aperture,\n        and the magnification, both of which a floating\n        point (real) numbers.\n        The values are those that are fixed for a particular\n        objective: either because it has been manufactured to\n        this specification or the value has been measured on\n        this particular objective.\n        Correction: This is the type of correction coating applied to this lens.\n        Immersion: This is the types of immersion medium the lens is designed to\n        work with. It is not the same as 'Medium' in ObjectiveRef (a\n        single type) as here Immersion can have compound values like 'Multi'.\n        LensNA: The numerical aperture of the lens (as a float)\n        NominalMagnification: The specified magnification e.g. x10\n        CalibratedMagnification: The measured magnification e.g. x10.3\n        WorkingDistance: WorkingDistance of the lens.\n      ")

    
    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}Detector uses Python identifier Detector
    __Detector = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'Detector'), 'Detector', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_21_httpwww_openmicroscopy_orgSchemasOME2016_06Detector', True, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2144, 2), )

    
    Detector = property(__Detector.value, __Detector.set, None, '\n        The type of detector used to capture the image.\n        The Detector ID can be used as a reference within the Channel element in the Image element.\n        The values stored in Detector represent the fixed values,\n        variable values modified during the acquisition go in DetectorSettings\n\n        Each attribute now has an indication of what type of detector\n        it applies to. This is preparatory work for cleaning up and\n        possibly splitting this object into sub-types.\n      ')

    
    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}FilterSet uses Python identifier FilterSet
    __FilterSet = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'FilterSet'), 'FilterSet', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_21_httpwww_openmicroscopy_orgSchemasOME2016_06FilterSet', True, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2242, 2), )

    
    FilterSet = property(__FilterSet.value, __FilterSet.set, None, 'Filter set manufacturer specification')

    
    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}Filter uses Python identifier Filter
    __Filter = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'Filter'), 'Filter', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_21_httpwww_openmicroscopy_orgSchemasOME2016_06Filter', True, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2274, 2), )

    
    Filter = property(__Filter.value, __Filter.set, None, "\n        A filter is either an excitation or emission filters.\n        There should be one filter element specified per wavelength in the image.\n        The channel number associated with a filter set is specified in Channel.\n        It is based on the FilterSpec type, so has the required attributes Manufacturer, Model, and LotNumber.\n        It may also contain a Type attribute which may be set to\n        'LongPass', 'ShortPass', 'BandPass', 'MultiPass',\n        'Dichroic', 'NeutralDensity', 'Tuneable' or 'Other'.\n        It can be associated with an optional FilterWheel - Note: this is not the same as a FilterSet\n      ")

    
    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}Dichroic uses Python identifier Dichroic
    __Dichroic = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'Dichroic'), 'Dichroic', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_21_httpwww_openmicroscopy_orgSchemasOME2016_06Dichroic', True, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2391, 2), )

    
    Dichroic = property(__Dichroic.value, __Dichroic.set, None, 'The dichromatic beamsplitter or dichroic mirror used for this filter combination.')

    
    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}LightSourceGroup uses Python identifier LightSourceGroup
    __LightSourceGroup = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'LightSourceGroup'), 'LightSourceGroup', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_21_httpwww_openmicroscopy_orgSchemasOME2016_06LightSourceGroup', True, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2454, 2), )

    
    LightSourceGroup = property(__LightSourceGroup.value, __LightSourceGroup.set, None, None)

    
    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}AnnotationRef uses Python identifier AnnotationRef
    __AnnotationRef = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'AnnotationRef'), 'AnnotationRef', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_21_httpwww_openmicroscopy_orgSchemasOME2016_06AnnotationRef', True, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3435, 2), )

    
    AnnotationRef = property(__AnnotationRef.value, __AnnotationRef.set, None, '\n        The AnnotationRef element is a reference to an element derived\n        from the CommonAnnotation element.\n      ')

    
    # Attribute ID uses Python identifier ID
    __ID = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'ID'), 'ID', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_21_ID', _module_typeBindings.InstrumentID, required=True)
    __ID._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1013, 6)
    __ID._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1013, 6)
    
    ID = property(__ID.value, __ID.set, None, None)

    _ElementMap.update({
        __Microscope.name() : __Microscope,
        __Objective.name() : __Objective,
        __Detector.name() : __Detector,
        __FilterSet.name() : __FilterSet,
        __Filter.name() : __Filter,
        __Dichroic.name() : __Dichroic,
        __LightSourceGroup.name() : __LightSourceGroup,
        __AnnotationRef.name() : __AnnotationRef
    })
    _AttributeMap.update({
        __ID.name() : __ID
    })
_module_typeBindings.CTD_ANON_21 = CTD_ANON_21


# Complex type [anonymous] with content type ELEMENT_ONLY
class CTD_ANON_22 (pyxb.binding.basis.complexTypeDefinition):
    """
        The Project ID is required.
        Datasets can be grouped into projects using a many-to-many relationship.
        A Dataset may belong to one or more Projects by including one or more ProjectRef elements which refer to Project IDs.
        Projects do not directly contain images - only by virtue of containing datasets, which themselves contain images.
      """
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = None
    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1111, 4)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}Description uses Python identifier Description
    __Description = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'Description'), 'Description', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_22_httpwww_openmicroscopy_orgSchemasOME2016_06Description', False, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1113, 8), )

    
    Description = property(__Description.value, __Description.set, None, '\n              A description for the project. [plain-text multi-line string]\n            ')

    
    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}ExperimenterRef uses Python identifier ExperimenterRef
    __ExperimenterRef = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'ExperimenterRef'), 'ExperimenterRef', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_22_httpwww_openmicroscopy_orgSchemasOME2016_06ExperimenterRef', False, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2909, 2), )

    
    ExperimenterRef = property(__ExperimenterRef.value, __ExperimenterRef.set, None, '\n        This empty element has a required Experimenter ID and an optional DocumentID attribute which refers to one of the Experimenters defined within OME.\n      ')

    
    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}ExperimenterGroupRef uses Python identifier ExperimenterGroupRef
    __ExperimenterGroupRef = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'ExperimenterGroupRef'), 'ExperimenterGroupRef', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_22_httpwww_openmicroscopy_orgSchemasOME2016_06ExperimenterGroupRef', False, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2923, 2), )

    
    ExperimenterGroupRef = property(__ExperimenterGroupRef.value, __ExperimenterGroupRef.set, None, 'This empty element has a reference (the ExperimenterGroup ID attribute) to a ExperimenterGroup defined within OME.')

    
    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}DatasetRef uses Python identifier DatasetRef
    __DatasetRef = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'DatasetRef'), 'DatasetRef', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_22_httpwww_openmicroscopy_orgSchemasOME2016_06DatasetRef', True, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2949, 2), )

    
    DatasetRef = property(__DatasetRef.value, __DatasetRef.set, None, '\n        The DatasetRef element refers to a Dataset by specifying the Dataset ID attribute.\n        One or more DatasetRef elements may be listed within the Image element to specify what Datasets\n        the Image belongs to.\n      ')

    
    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}AnnotationRef uses Python identifier AnnotationRef
    __AnnotationRef = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'AnnotationRef'), 'AnnotationRef', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_22_httpwww_openmicroscopy_orgSchemasOME2016_06AnnotationRef', True, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3435, 2), )

    
    AnnotationRef = property(__AnnotationRef.value, __AnnotationRef.set, None, '\n        The AnnotationRef element is a reference to an element derived\n        from the CommonAnnotation element.\n      ')

    
    # Attribute Name uses Python identifier Name
    __Name = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'Name'), 'Name', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_22_Name', pyxb.binding.datatypes.string)
    __Name._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1138, 6)
    __Name._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1138, 6)
    
    Name = property(__Name.value, __Name.set, None, None)

    
    # Attribute ID uses Python identifier ID
    __ID = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'ID'), 'ID', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_22_ID', _module_typeBindings.ProjectID, required=True)
    __ID._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1139, 6)
    __ID._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1139, 6)
    
    ID = property(__ID.value, __ID.set, None, None)

    _ElementMap.update({
        __Description.name() : __Description,
        __ExperimenterRef.name() : __ExperimenterRef,
        __ExperimenterGroupRef.name() : __ExperimenterGroupRef,
        __DatasetRef.name() : __DatasetRef,
        __AnnotationRef.name() : __AnnotationRef
    })
    _AttributeMap.update({
        __Name.name() : __Name,
        __ID.name() : __ID
    })
_module_typeBindings.CTD_ANON_22 = CTD_ANON_22


# Complex type [anonymous] with content type ELEMENT_ONLY
class CTD_ANON_23 (pyxb.binding.basis.complexTypeDefinition):
    """
        The ExperimenterGroupID is required.
        Information should ideally be specified for at least one Leader as a contact for the group.
        The Leaders are themselves Experimenters.
      """
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = None
    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1151, 4)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}Description uses Python identifier Description
    __Description = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'Description'), 'Description', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_23_httpwww_openmicroscopy_orgSchemasOME2016_06Description', False, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1153, 8), )

    
    Description = property(__Description.value, __Description.set, None, '\n              A description for the group. [plain-text multi-line string]\n            ')

    
    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}Leader uses Python identifier Leader
    __Leader = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'Leader'), 'Leader', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_23_httpwww_openmicroscopy_orgSchemasOME2016_06Leader', True, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1185, 2), )

    
    Leader = property(__Leader.value, __Leader.set, None, '\n        Contact information for a ExperimenterGroup leader specified using a reference\n        to an Experimenter element defined elsewhere in the document.\n      ')

    
    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}ExperimenterRef uses Python identifier ExperimenterRef
    __ExperimenterRef = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'ExperimenterRef'), 'ExperimenterRef', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_23_httpwww_openmicroscopy_orgSchemasOME2016_06ExperimenterRef', True, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2909, 2), )

    
    ExperimenterRef = property(__ExperimenterRef.value, __ExperimenterRef.set, None, '\n        This empty element has a required Experimenter ID and an optional DocumentID attribute which refers to one of the Experimenters defined within OME.\n      ')

    
    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}AnnotationRef uses Python identifier AnnotationRef
    __AnnotationRef = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'AnnotationRef'), 'AnnotationRef', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_23_httpwww_openmicroscopy_orgSchemasOME2016_06AnnotationRef', True, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3435, 2), )

    
    AnnotationRef = property(__AnnotationRef.value, __AnnotationRef.set, None, '\n        The AnnotationRef element is a reference to an element derived\n        from the CommonAnnotation element.\n      ')

    
    # Attribute Name uses Python identifier Name
    __Name = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'Name'), 'Name', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_23_Name', pyxb.binding.datatypes.string)
    __Name._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1177, 6)
    __Name._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1177, 6)
    
    Name = property(__Name.value, __Name.set, None, '')

    
    # Attribute ID uses Python identifier ID
    __ID = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'ID'), 'ID', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_23_ID', _module_typeBindings.ExperimenterGroupID, required=True)
    __ID._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1182, 6)
    __ID._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1182, 6)
    
    ID = property(__ID.value, __ID.set, None, None)

    _ElementMap.update({
        __Description.name() : __Description,
        __Leader.name() : __Leader,
        __ExperimenterRef.name() : __ExperimenterRef,
        __AnnotationRef.name() : __AnnotationRef
    })
    _AttributeMap.update({
        __Name.name() : __Name,
        __ID.name() : __ID
    })
_module_typeBindings.CTD_ANON_23 = CTD_ANON_23


# Complex type [anonymous] with content type EMPTY
class CTD_ANON_24 (Reference):
    """
        Contact information for a ExperimenterGroup leader specified using a reference
        to an Experimenter element defined elsewhere in the document.
      """
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_EMPTY
    _Abstract = False
    _ExpandedName = None
    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1193, 4)
    _ElementMap = Reference._ElementMap.copy()
    _AttributeMap = Reference._AttributeMap.copy()
    # Base type is Reference
    
    # Attribute ID uses Python identifier ID
    __ID = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'ID'), 'ID', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_24_ID', _module_typeBindings.ExperimenterID, required=True)
    __ID._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1196, 10)
    __ID._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1196, 10)
    
    ID = property(__ID.value, __ID.set, None, None)

    _ElementMap.update({
        
    })
    _AttributeMap.update({
        __ID.name() : __ID
    })
_module_typeBindings.CTD_ANON_24 = CTD_ANON_24


# Complex type [anonymous] with content type ELEMENT_ONLY
class CTD_ANON_25 (pyxb.binding.basis.complexTypeDefinition):
    """
        An element specifying a collection of images that are always processed together.
        Images can belong to more than one Dataset, and a Dataset may contain more than one Image.
        Images contain one or more DatasetRef elements to specify what datasets they belong to.
        Once a Dataset has been processed in any way, its collection of images cannot be altered.
        The ExperimenterRef and ExperimenterGroupRef elements specify the person and group this Dataset belongs to.
        Projects may contain one or more Datasets, and Datasets may belong to one or more Projects.
        This relationship is specified by listing DatasetRef elements within the Project element.
      """
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = None
    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1214, 4)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}Description uses Python identifier Description
    __Description = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'Description'), 'Description', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_25_httpwww_openmicroscopy_orgSchemasOME2016_06Description', False, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1216, 8), )

    
    Description = property(__Description.value, __Description.set, None, '\n              A description for the dataset. [plain-text multi-line string]\n            ')

    
    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}ImageRef uses Python identifier ImageRef
    __ImageRef = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'ImageRef'), 'ImageRef', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_25_httpwww_openmicroscopy_orgSchemasOME2016_06ImageRef', True, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2844, 2), )

    
    ImageRef = property(__ImageRef.value, __ImageRef.set, None, '\n        The ImageRef element is a reference to an Image element.\n      ')

    
    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}ExperimenterRef uses Python identifier ExperimenterRef
    __ExperimenterRef = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'ExperimenterRef'), 'ExperimenterRef', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_25_httpwww_openmicroscopy_orgSchemasOME2016_06ExperimenterRef', False, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2909, 2), )

    
    ExperimenterRef = property(__ExperimenterRef.value, __ExperimenterRef.set, None, '\n        This empty element has a required Experimenter ID and an optional DocumentID attribute which refers to one of the Experimenters defined within OME.\n      ')

    
    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}ExperimenterGroupRef uses Python identifier ExperimenterGroupRef
    __ExperimenterGroupRef = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'ExperimenterGroupRef'), 'ExperimenterGroupRef', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_25_httpwww_openmicroscopy_orgSchemasOME2016_06ExperimenterGroupRef', False, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2923, 2), )

    
    ExperimenterGroupRef = property(__ExperimenterGroupRef.value, __ExperimenterGroupRef.set, None, 'This empty element has a reference (the ExperimenterGroup ID attribute) to a ExperimenterGroup defined within OME.')

    
    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}AnnotationRef uses Python identifier AnnotationRef
    __AnnotationRef = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'AnnotationRef'), 'AnnotationRef', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_25_httpwww_openmicroscopy_orgSchemasOME2016_06AnnotationRef', True, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3435, 2), )

    
    AnnotationRef = property(__AnnotationRef.value, __AnnotationRef.set, None, '\n        The AnnotationRef element is a reference to an element derived\n        from the CommonAnnotation element.\n      ')

    
    # Attribute Name uses Python identifier Name
    __Name = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'Name'), 'Name', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_25_Name', pyxb.binding.datatypes.string)
    __Name._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1241, 6)
    __Name._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1241, 6)
    
    Name = property(__Name.value, __Name.set, None, '\n            A name for the dataset that is suitable for presentation to the user.\n          ')

    
    # Attribute ID uses Python identifier ID
    __ID = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'ID'), 'ID', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_25_ID', _module_typeBindings.DatasetID, required=True)
    __ID._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1248, 6)
    __ID._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1248, 6)
    
    ID = property(__ID.value, __ID.set, None, None)

    _ElementMap.update({
        __Description.name() : __Description,
        __ImageRef.name() : __ImageRef,
        __ExperimenterRef.name() : __ExperimenterRef,
        __ExperimenterGroupRef.name() : __ExperimenterGroupRef,
        __AnnotationRef.name() : __AnnotationRef
    })
    _AttributeMap.update({
        __Name.name() : __Name,
        __ID.name() : __ID
    })
_module_typeBindings.CTD_ANON_25 = CTD_ANON_25


# Complex type [anonymous] with content type ELEMENT_ONLY
class CTD_ANON_26 (pyxb.binding.basis.complexTypeDefinition):
    """
        This element describes the type of experiment.  The required Type attribute must contain one or more entries from the following list:
        FP FRET Time-lapse 4-D+ Screen Immunocytochemistry FISH Electrophysiology  Ion-Imaging Colocalization PGI/Documentation
        FRAP Photoablation Optical-Trapping Photoactivation Fluorescence-Lifetime Spectral-Imaging Other
        FP refers to fluorescent proteins, PGI/Documentation is not a 'data' image.
        The optional Description element may contain free text to further describe the experiment.
      """
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = None
    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1262, 4)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}MicrobeamManipulation uses Python identifier MicrobeamManipulation
    __MicrobeamManipulation = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'MicrobeamManipulation'), 'MicrobeamManipulation', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_26_httpwww_openmicroscopy_orgSchemasOME2016_06MicrobeamManipulation', True, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 920, 2), )

    
    MicrobeamManipulation = property(__MicrobeamManipulation.value, __MicrobeamManipulation.set, None, '\n        Defines a microbeam operation type and the region of the image it was applied to.\n        The LightSourceRef element is a reference to a LightSource specified in the Instrument element which was used for a technique other than illumination for\n        the purpose of imaging. For example, a laser used for photobleaching.\n      ')

    
    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}Description uses Python identifier Description
    __Description = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'Description'), 'Description', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_26_httpwww_openmicroscopy_orgSchemasOME2016_06Description', False, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1264, 8), )

    
    Description = property(__Description.value, __Description.set, None, '\n              A description for the experiment. [plain-text multi-line string]\n            ')

    
    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}ExperimenterRef uses Python identifier ExperimenterRef
    __ExperimenterRef = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'ExperimenterRef'), 'ExperimenterRef', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_26_httpwww_openmicroscopy_orgSchemasOME2016_06ExperimenterRef', False, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2909, 2), )

    
    ExperimenterRef = property(__ExperimenterRef.value, __ExperimenterRef.set, None, '\n        This empty element has a required Experimenter ID and an optional DocumentID attribute which refers to one of the Experimenters defined within OME.\n      ')

    
    # Attribute Type uses Python identifier Type
    __Type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'Type'), 'Type', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_26_Type', _module_typeBindings.STD_ANON_38)
    __Type._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1285, 6)
    __Type._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1285, 6)
    
    Type = property(__Type.value, __Type.set, None, '\n            A term to describe the type of experiment.\n          ')

    
    # Attribute ID uses Python identifier ID
    __ID = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'ID'), 'ID', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_26_ID', _module_typeBindings.ExperimentID, required=True)
    __ID._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1317, 6)
    __ID._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1317, 6)
    
    ID = property(__ID.value, __ID.set, None, None)

    _ElementMap.update({
        __MicrobeamManipulation.name() : __MicrobeamManipulation,
        __Description.name() : __Description,
        __ExperimenterRef.name() : __ExperimenterRef
    })
    _AttributeMap.update({
        __Type.name() : __Type,
        __ID.name() : __ID
    })
_module_typeBindings.CTD_ANON_26 = CTD_ANON_26


# Complex type [anonymous] with content type ELEMENT_ONLY
class CTD_ANON_27 (pyxb.binding.basis.complexTypeDefinition):
    """
        This element describes a person who performed an imaging experiment.
        This person may also be a user of the OME system, in which case the UserName element contains their login name.
        Experimenters may belong to one or more groups which are specified using one or more ExperimenterGroupRef elements.
      """
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = None
    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1329, 4)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}AnnotationRef uses Python identifier AnnotationRef
    __AnnotationRef = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'AnnotationRef'), 'AnnotationRef', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_27_httpwww_openmicroscopy_orgSchemasOME2016_06AnnotationRef', True, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3435, 2), )

    
    AnnotationRef = property(__AnnotationRef.value, __AnnotationRef.set, None, '\n        The AnnotationRef element is a reference to an element derived\n        from the CommonAnnotation element.\n      ')

    
    # Attribute ID uses Python identifier ID
    __ID = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'ID'), 'ID', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_27_ID', _module_typeBindings.ExperimenterID, required=True)
    __ID._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1337, 6)
    __ID._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1337, 6)
    
    ID = property(__ID.value, __ID.set, None, None)

    
    # Attribute FirstName uses Python identifier FirstName
    __FirstName = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'FirstName'), 'FirstName', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_27_FirstName', pyxb.binding.datatypes.string)
    __FirstName._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1338, 6)
    __FirstName._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1338, 6)
    
    FirstName = property(__FirstName.value, __FirstName.set, None, 'First name, sometime called christian name or given name or forename. [plain text string]')

    
    # Attribute MiddleName uses Python identifier MiddleName
    __MiddleName = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'MiddleName'), 'MiddleName', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_27_MiddleName', pyxb.binding.datatypes.string)
    __MiddleName._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1343, 6)
    __MiddleName._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1343, 6)
    
    MiddleName = property(__MiddleName.value, __MiddleName.set, None, 'Any other names. [plain text string]')

    
    # Attribute LastName uses Python identifier LastName
    __LastName = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'LastName'), 'LastName', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_27_LastName', pyxb.binding.datatypes.string)
    __LastName._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1348, 6)
    __LastName._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1348, 6)
    
    LastName = property(__LastName.value, __LastName.set, None, "A person's last name sometimes called surname or family name. [plain text string]")

    
    # Attribute Email uses Python identifier Email
    __Email = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'Email'), 'Email', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_27_Email', pyxb.binding.datatypes.string)
    __Email._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1353, 6)
    __Email._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1353, 6)
    
    Email = property(__Email.value, __Email.set, None, "A person's email address. [valid email address as string]")

    
    # Attribute Institution uses Python identifier Institution
    __Institution = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'Institution'), 'Institution', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_27_Institution', pyxb.binding.datatypes.string)
    __Institution._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1358, 6)
    __Institution._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1358, 6)
    
    Institution = property(__Institution.value, __Institution.set, None, "\n            A person's Institution\n            The organizing structure that people belong to other than groups.  A university, or company, etc.\n            We do not specify a department element, and do not mean for Institution to be used in this way.\n            We simply wish to say XXX at YYY.  Where YYY has a better chance of being tied to a geographically fixed location\n            and of being more recognizable than a group of experimenters. [plain text string]\n          ")

    
    # Attribute UserName uses Python identifier UserName
    __UserName = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'UserName'), 'UserName', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_27_UserName', pyxb.binding.datatypes.string)
    __UserName._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1369, 6)
    __UserName._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1369, 6)
    
    UserName = property(__UserName.value, __UserName.set, None, "This is the username of the experimenter (in a 'unix' or 'database' sense). [plain text string]")

    _ElementMap.update({
        __AnnotationRef.name() : __AnnotationRef
    })
    _AttributeMap.update({
        __ID.name() : __ID,
        __FirstName.name() : __FirstName,
        __MiddleName.name() : __MiddleName,
        __LastName.name() : __LastName,
        __Email.name() : __Email,
        __Institution.name() : __Institution,
        __UserName.name() : __UserName
    })
_module_typeBindings.CTD_ANON_27 = CTD_ANON_27


# Complex type [anonymous] with content type ELEMENT_ONLY
class CTD_ANON_28 (pyxb.binding.basis.complexTypeDefinition):
    """
        An element specifying a possibly heterogeneous collection of data.
        Folders may contain Folders so that data may be organized within a tree of Folders.
        Data may be in multiple Folders but a Folder may not be in more than one other Folder.
      """
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = None
    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1386, 4)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}Description uses Python identifier Description
    __Description = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'Description'), 'Description', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_28_httpwww_openmicroscopy_orgSchemasOME2016_06Description', False, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1388, 8), )

    
    Description = property(__Description.value, __Description.set, None, '\n              A description for the folder. [plain-text multi-line string]\n            ')

    
    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}ImageRef uses Python identifier ImageRef
    __ImageRef = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'ImageRef'), 'ImageRef', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_28_httpwww_openmicroscopy_orgSchemasOME2016_06ImageRef', True, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2844, 2), )

    
    ImageRef = property(__ImageRef.value, __ImageRef.set, None, '\n        The ImageRef element is a reference to an Image element.\n      ')

    
    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}FolderRef uses Python identifier FolderRef
    __FolderRef = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'FolderRef'), 'FolderRef', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_28_httpwww_openmicroscopy_orgSchemasOME2016_06FolderRef', True, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2965, 2), )

    
    FolderRef = property(__FolderRef.value, __FolderRef.set, None, '\n        The FolderRef element refers to a Folder by specifying the Folder ID attribute.\n        One or more FolderRef elements may be listed within the Folder element to specify what Folders\n        the Folder contains. This tree hierarchy must be acyclic.\n      ')

    
    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}AnnotationRef uses Python identifier AnnotationRef
    __AnnotationRef = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'AnnotationRef'), 'AnnotationRef', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_28_httpwww_openmicroscopy_orgSchemasOME2016_06AnnotationRef', True, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3435, 2), )

    
    AnnotationRef = property(__AnnotationRef.value, __AnnotationRef.set, None, '\n        The AnnotationRef element is a reference to an element derived\n        from the CommonAnnotation element.\n      ')

    
    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}ROIRef uses Python identifier ROIRef
    __ROIRef = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'ROIRef'), 'ROIRef', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_28_httpwww_openmicroscopy_orgSchemasOME2016_06ROIRef', True, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4247, 2), )

    
    ROIRef = property(__ROIRef.value, __ROIRef.set, None, None)

    
    # Attribute ID uses Python identifier ID
    __ID = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'ID'), 'ID', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_28_ID', _module_typeBindings.FolderID, required=True)
    __ID._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1417, 6)
    __ID._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1417, 6)
    
    ID = property(__ID.value, __ID.set, None, None)

    
    # Attribute Name uses Python identifier Name
    __Name = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'Name'), 'Name', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_28_Name', pyxb.binding.datatypes.string)
    __Name._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1418, 6)
    __Name._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1418, 6)
    
    Name = property(__Name.value, __Name.set, None, '\n            A name for the folder that is suitable for presentation to the user.\n          ')

    _ElementMap.update({
        __Description.name() : __Description,
        __ImageRef.name() : __ImageRef,
        __FolderRef.name() : __FolderRef,
        __AnnotationRef.name() : __AnnotationRef,
        __ROIRef.name() : __ROIRef
    })
    _AttributeMap.update({
        __ID.name() : __ID,
        __Name.name() : __Name
    })
_module_typeBindings.CTD_ANON_28 = CTD_ANON_28


# Complex type [anonymous] with content type ELEMENT_ONLY
class CTD_ANON_29 (ManufacturerSpec):
    """
        A description of the microscope's objective lens.
        Required elements include the lens numerical aperture,
        and the magnification, both of which a floating
        point (real) numbers.
        The values are those that are fixed for a particular
        objective: either because it has been manufactured to
        this specification or the value has been measured on
        this particular objective.
        Correction: This is the type of correction coating applied to this lens.
        Immersion: This is the types of immersion medium the lens is designed to
        work with. It is not the same as 'Medium' in ObjectiveRef (a
        single type) as here Immersion can have compound values like 'Multi'.
        LensNA: The numerical aperture of the lens (as a float)
        NominalMagnification: The specified magnification e.g. x10
        CalibratedMagnification: The measured magnification e.g. x10.3
        WorkingDistance: WorkingDistance of the lens.
      """
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = None
    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2046, 4)
    _ElementMap = ManufacturerSpec._ElementMap.copy()
    _AttributeMap = ManufacturerSpec._AttributeMap.copy()
    # Base type is ManufacturerSpec
    
    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}AnnotationRef uses Python identifier AnnotationRef
    __AnnotationRef = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'AnnotationRef'), 'AnnotationRef', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_29_httpwww_openmicroscopy_orgSchemasOME2016_06AnnotationRef', True, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3435, 2), )

    
    AnnotationRef = property(__AnnotationRef.value, __AnnotationRef.set, None, '\n        The AnnotationRef element is a reference to an element derived\n        from the CommonAnnotation element.\n      ')

    
    # Attribute Manufacturer inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}ManufacturerSpec
    
    # Attribute Model inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}ManufacturerSpec
    
    # Attribute SerialNumber inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}ManufacturerSpec
    
    # Attribute LotNumber inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}ManufacturerSpec
    
    # Attribute ID uses Python identifier ID
    __ID = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'ID'), 'ID', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_29_ID', _module_typeBindings.ObjectiveID, required=True)
    __ID._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2056, 10)
    __ID._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2056, 10)
    
    ID = property(__ID.value, __ID.set, None, None)

    
    # Attribute Correction uses Python identifier Correction
    __Correction = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'Correction'), 'Correction', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_29_Correction', _module_typeBindings.STD_ANON_14)
    __Correction._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2057, 10)
    __Correction._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2057, 10)
    
    Correction = property(__Correction.value, __Correction.set, None, 'The correction applied to the lens')

    
    # Attribute Immersion uses Python identifier Immersion
    __Immersion = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'Immersion'), 'Immersion', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_29_Immersion', _module_typeBindings.STD_ANON_15)
    __Immersion._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2081, 10)
    __Immersion._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2081, 10)
    
    Immersion = property(__Immersion.value, __Immersion.set, None, 'The immersion medium the lens is designed for')

    
    # Attribute LensNA uses Python identifier LensNA
    __LensNA = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'LensNA'), 'LensNA', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_29_LensNA', pyxb.binding.datatypes.float)
    __LensNA._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2097, 10)
    __LensNA._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2097, 10)
    
    LensNA = property(__LensNA.value, __LensNA.set, None, '\n                The numerical aperture of the lens expressed as a floating point (real) number.\n                Expected range 0.02 - 1.5 [units:none]\n              ')

    
    # Attribute NominalMagnification uses Python identifier NominalMagnification
    __NominalMagnification = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'NominalMagnification'), 'NominalMagnification', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_29_NominalMagnification', pyxb.binding.datatypes.float)
    __NominalMagnification._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2105, 10)
    __NominalMagnification._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2105, 10)
    
    NominalMagnification = property(__NominalMagnification.value, __NominalMagnification.set, None, "\n                The magnification of the lens as specified by the manufacturer - i.e. '60' is a 60X lens. [units:none]\n                Note: The type of this has been changed from int to float to allow\n                the specification of additional lenses e.g. 0.5X lens\n              ")

    
    # Attribute CalibratedMagnification uses Python identifier CalibratedMagnification
    __CalibratedMagnification = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'CalibratedMagnification'), 'CalibratedMagnification', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_29_CalibratedMagnification', pyxb.binding.datatypes.float)
    __CalibratedMagnification._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2114, 10)
    __CalibratedMagnification._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2114, 10)
    
    CalibratedMagnification = property(__CalibratedMagnification.value, __CalibratedMagnification.set, None, "\n                The magnification of the lens as measured by a calibration process- i.e. '59.987' for a 60X lens. [units:none]\n              ")

    
    # Attribute WorkingDistance uses Python identifier WorkingDistance
    __WorkingDistance = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'WorkingDistance'), 'WorkingDistance', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_29_WorkingDistance', pyxb.binding.datatypes.float)
    __WorkingDistance._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2121, 10)
    __WorkingDistance._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2121, 10)
    
    WorkingDistance = property(__WorkingDistance.value, __WorkingDistance.set, None, '\n                The working distance of the lens expressed as a floating point (real) number. Units are set by WorkingDistanceUnit.\n              ')

    
    # Attribute WorkingDistanceUnit uses Python identifier WorkingDistanceUnit
    __WorkingDistanceUnit = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'WorkingDistanceUnit'), 'WorkingDistanceUnit', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_29_WorkingDistanceUnit', _module_typeBindings.UnitsLength, unicode_default='\xb5m')
    __WorkingDistanceUnit._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2128, 10)
    __WorkingDistanceUnit._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2128, 10)
    
    WorkingDistanceUnit = property(__WorkingDistanceUnit.value, __WorkingDistanceUnit.set, None, 'The units of the working distance - default:microns[\xb5m].')

    
    # Attribute Iris uses Python identifier Iris
    __Iris = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'Iris'), 'Iris', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_29_Iris', pyxb.binding.datatypes.boolean)
    __Iris._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2133, 10)
    __Iris._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2133, 10)
    
    Iris = property(__Iris.value, __Iris.set, None, '\n                Records whether or not the objective was fitted with an Iris. [flag]\n              ')

    _ElementMap.update({
        __AnnotationRef.name() : __AnnotationRef
    })
    _AttributeMap.update({
        __ID.name() : __ID,
        __Correction.name() : __Correction,
        __Immersion.name() : __Immersion,
        __LensNA.name() : __LensNA,
        __NominalMagnification.name() : __NominalMagnification,
        __CalibratedMagnification.name() : __CalibratedMagnification,
        __WorkingDistance.name() : __WorkingDistance,
        __WorkingDistanceUnit.name() : __WorkingDistanceUnit,
        __Iris.name() : __Iris
    })
_module_typeBindings.CTD_ANON_29 = CTD_ANON_29


# Complex type [anonymous] with content type ELEMENT_ONLY
class CTD_ANON_30 (ManufacturerSpec):
    """
        The type of detector used to capture the image.
        The Detector ID can be used as a reference within the Channel element in the Image element.
        The values stored in Detector represent the fixed values,
        variable values modified during the acquisition go in DetectorSettings

        Each attribute now has an indication of what type of detector
        it applies to. This is preparatory work for cleaning up and
        possibly splitting this object into sub-types.
      """
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = None
    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2158, 4)
    _ElementMap = ManufacturerSpec._ElementMap.copy()
    _AttributeMap = ManufacturerSpec._AttributeMap.copy()
    # Base type is ManufacturerSpec
    
    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}AnnotationRef uses Python identifier AnnotationRef
    __AnnotationRef = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'AnnotationRef'), 'AnnotationRef', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_30_httpwww_openmicroscopy_orgSchemasOME2016_06AnnotationRef', True, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3435, 2), )

    
    AnnotationRef = property(__AnnotationRef.value, __AnnotationRef.set, None, '\n        The AnnotationRef element is a reference to an element derived\n        from the CommonAnnotation element.\n      ')

    
    # Attribute Manufacturer inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}ManufacturerSpec
    
    # Attribute Model inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}ManufacturerSpec
    
    # Attribute SerialNumber inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}ManufacturerSpec
    
    # Attribute LotNumber inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}ManufacturerSpec
    
    # Attribute Gain uses Python identifier Gain
    __Gain = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'Gain'), 'Gain', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_30_Gain', pyxb.binding.datatypes.float)
    __Gain._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2168, 10)
    __Gain._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2168, 10)
    
    Gain = property(__Gain.value, __Gain.set, None, '\n                The Detector Gain for this detector, as a float. [units:none] {used:CCD,EMCCD,PMT}\n              ')

    
    # Attribute Voltage uses Python identifier Voltage
    __Voltage = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'Voltage'), 'Voltage', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_30_Voltage', pyxb.binding.datatypes.float)
    __Voltage._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2175, 10)
    __Voltage._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2175, 10)
    
    Voltage = property(__Voltage.value, __Voltage.set, None, '\n                The Voltage of the detector (e.g. PMT voltage) as a float. {used:PMT}\n                Units are set by VoltageUnit.\n              ')

    
    # Attribute VoltageUnit uses Python identifier VoltageUnit
    __VoltageUnit = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'VoltageUnit'), 'VoltageUnit', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_30_VoltageUnit', _module_typeBindings.UnitsElectricPotential, unicode_default='V')
    __VoltageUnit._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2183, 10)
    __VoltageUnit._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2183, 10)
    
    VoltageUnit = property(__VoltageUnit.value, __VoltageUnit.set, None, 'The units of the Voltage - default:volts[V].')

    
    # Attribute Offset uses Python identifier Offset
    __Offset = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'Offset'), 'Offset', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_30_Offset', pyxb.binding.datatypes.float)
    __Offset._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2188, 10)
    __Offset._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2188, 10)
    
    Offset = property(__Offset.value, __Offset.set, None, '\n                The Detector Offset. [units:none] {used:CCD,EMCCD}\n              ')

    
    # Attribute Zoom uses Python identifier Zoom
    __Zoom = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'Zoom'), 'Zoom', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_30_Zoom', pyxb.binding.datatypes.float)
    __Zoom._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2195, 10)
    __Zoom._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2195, 10)
    
    Zoom = property(__Zoom.value, __Zoom.set, None, '\n                The fixed Zoom for a detector. [units:none] {used:PMT}\n              ')

    
    # Attribute AmplificationGain uses Python identifier AmplificationGain
    __AmplificationGain = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'AmplificationGain'), 'AmplificationGain', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_30_AmplificationGain', pyxb.binding.datatypes.float)
    __AmplificationGain._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2202, 10)
    __AmplificationGain._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2202, 10)
    
    AmplificationGain = property(__AmplificationGain.value, __AmplificationGain.set, None, '\n                Gain applied to the detector signal.\n                This is the electronic gain (as apposed to the inherent gain) that is set for the detector. [units:none] {used:EMCCD#EMGain}\n              ')

    
    # Attribute ID uses Python identifier ID
    __ID = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'ID'), 'ID', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_30_ID', _module_typeBindings.DetectorID, required=True)
    __ID._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2210, 10)
    __ID._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2210, 10)
    
    ID = property(__ID.value, __ID.set, None, None)

    
    # Attribute Type uses Python identifier Type
    __Type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'Type'), 'Type', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_30_Type', _module_typeBindings.STD_ANON_16)
    __Type._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2211, 10)
    __Type._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2211, 10)
    
    Type = property(__Type.value, __Type.set, None, '\n                The Type of detector. E.g. CCD, PMT, EMCCD etc.\n              ')

    _ElementMap.update({
        __AnnotationRef.name() : __AnnotationRef
    })
    _AttributeMap.update({
        __Gain.name() : __Gain,
        __Voltage.name() : __Voltage,
        __VoltageUnit.name() : __VoltageUnit,
        __Offset.name() : __Offset,
        __Zoom.name() : __Zoom,
        __AmplificationGain.name() : __AmplificationGain,
        __ID.name() : __ID,
        __Type.name() : __Type
    })
_module_typeBindings.CTD_ANON_30 = CTD_ANON_30


# Complex type [anonymous] with content type ELEMENT_ONLY
class CTD_ANON_31 (ManufacturerSpec):
    """Filter set manufacturer specification"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = None
    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2247, 4)
    _ElementMap = ManufacturerSpec._ElementMap.copy()
    _AttributeMap = ManufacturerSpec._AttributeMap.copy()
    # Base type is ManufacturerSpec
    
    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}ExcitationFilterRef uses Python identifier ExcitationFilterRef
    __ExcitationFilterRef = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'ExcitationFilterRef'), 'ExcitationFilterRef', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_31_httpwww_openmicroscopy_orgSchemasOME2016_06ExcitationFilterRef', True, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2251, 12), )

    
    ExcitationFilterRef = property(__ExcitationFilterRef.value, __ExcitationFilterRef.set, None, '\n                  The Filters placed in the Excitation light path.\n                ')

    
    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}EmissionFilterRef uses Python identifier EmissionFilterRef
    __EmissionFilterRef = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'EmissionFilterRef'), 'EmissionFilterRef', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_31_httpwww_openmicroscopy_orgSchemasOME2016_06EmissionFilterRef', True, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2260, 12), )

    
    EmissionFilterRef = property(__EmissionFilterRef.value, __EmissionFilterRef.set, None, '\n                  The Filters placed in the Emission light path.\n                ')

    
    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}DichroicRef uses Python identifier DichroicRef
    __DichroicRef = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'DichroicRef'), 'DichroicRef', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_31_httpwww_openmicroscopy_orgSchemasOME2016_06DichroicRef', False, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2443, 2), )

    
    DichroicRef = property(__DichroicRef.value, __DichroicRef.set, None, None)

    
    # Attribute Manufacturer inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}ManufacturerSpec
    
    # Attribute Model inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}ManufacturerSpec
    
    # Attribute SerialNumber inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}ManufacturerSpec
    
    # Attribute LotNumber inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}ManufacturerSpec
    
    # Attribute ID uses Python identifier ID
    __ID = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'ID'), 'ID', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_31_ID', _module_typeBindings.FilterSetID, required=True)
    __ID._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2269, 10)
    __ID._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2269, 10)
    
    ID = property(__ID.value, __ID.set, None, None)

    _ElementMap.update({
        __ExcitationFilterRef.name() : __ExcitationFilterRef,
        __EmissionFilterRef.name() : __EmissionFilterRef,
        __DichroicRef.name() : __DichroicRef
    })
    _AttributeMap.update({
        __ID.name() : __ID
    })
_module_typeBindings.CTD_ANON_31 = CTD_ANON_31


# Complex type [anonymous] with content type ELEMENT_ONLY
class CTD_ANON_32 (ManufacturerSpec):
    """
        A filter is either an excitation or emission filters.
        There should be one filter element specified per wavelength in the image.
        The channel number associated with a filter set is specified in Channel.
        It is based on the FilterSpec type, so has the required attributes Manufacturer, Model, and LotNumber.
        It may also contain a Type attribute which may be set to
        'LongPass', 'ShortPass', 'BandPass', 'MultiPass',
        'Dichroic', 'NeutralDensity', 'Tuneable' or 'Other'.
        It can be associated with an optional FilterWheel - Note: this is not the same as a FilterSet
      """
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = None
    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2288, 4)
    _ElementMap = ManufacturerSpec._ElementMap.copy()
    _AttributeMap = ManufacturerSpec._AttributeMap.copy()
    # Base type is ManufacturerSpec
    
    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}TransmittanceRange uses Python identifier TransmittanceRange
    __TransmittanceRange = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'TransmittanceRange'), 'TransmittanceRange', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_32_httpwww_openmicroscopy_orgSchemasOME2016_06TransmittanceRange', False, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2325, 2), )

    
    TransmittanceRange = property(__TransmittanceRange.value, __TransmittanceRange.set, None, '\n        This records the range of wavelengths that are transmitted by the filter. It also records the maximum amount of light transmitted.\n      ')

    
    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}AnnotationRef uses Python identifier AnnotationRef
    __AnnotationRef = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'AnnotationRef'), 'AnnotationRef', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_32_httpwww_openmicroscopy_orgSchemasOME2016_06AnnotationRef', True, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3435, 2), )

    
    AnnotationRef = property(__AnnotationRef.value, __AnnotationRef.set, None, '\n        The AnnotationRef element is a reference to an element derived\n        from the CommonAnnotation element.\n      ')

    
    # Attribute Manufacturer inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}ManufacturerSpec
    
    # Attribute Model inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}ManufacturerSpec
    
    # Attribute SerialNumber inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}ManufacturerSpec
    
    # Attribute LotNumber inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}ManufacturerSpec
    
    # Attribute Type uses Python identifier Type
    __Type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'Type'), 'Type', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_32_Type', _module_typeBindings.STD_ANON_17)
    __Type._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2299, 10)
    __Type._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2299, 10)
    
    Type = property(__Type.value, __Type.set, None, None)

    
    # Attribute FilterWheel uses Python identifier FilterWheel
    __FilterWheel = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'FilterWheel'), 'FilterWheel', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_32_FilterWheel', pyxb.binding.datatypes.string)
    __FilterWheel._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2313, 10)
    __FilterWheel._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2313, 10)
    
    FilterWheel = property(__FilterWheel.value, __FilterWheel.set, None, "\n                A filter 'wheel' in OME can refer to any arrangement of filters in a filter holder of any shape. It could, for example, be a filter slider. [plain text string]\n              ")

    
    # Attribute ID uses Python identifier ID
    __ID = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'ID'), 'ID', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_32_ID', _module_typeBindings.FilterID, required=True)
    __ID._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2320, 10)
    __ID._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2320, 10)
    
    ID = property(__ID.value, __ID.set, None, None)

    _ElementMap.update({
        __TransmittanceRange.name() : __TransmittanceRange,
        __AnnotationRef.name() : __AnnotationRef
    })
    _AttributeMap.update({
        __Type.name() : __Type,
        __FilterWheel.name() : __FilterWheel,
        __ID.name() : __ID
    })
_module_typeBindings.CTD_ANON_32 = CTD_ANON_32


# Complex type [anonymous] with content type ELEMENT_ONLY
class CTD_ANON_33 (ManufacturerSpec):
    """The dichromatic beamsplitter or dichroic mirror used for this filter combination."""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = None
    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2396, 4)
    _ElementMap = ManufacturerSpec._ElementMap.copy()
    _AttributeMap = ManufacturerSpec._AttributeMap.copy()
    # Base type is ManufacturerSpec
    
    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}AnnotationRef uses Python identifier AnnotationRef
    __AnnotationRef = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'AnnotationRef'), 'AnnotationRef', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_33_httpwww_openmicroscopy_orgSchemasOME2016_06AnnotationRef', True, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3435, 2), )

    
    AnnotationRef = property(__AnnotationRef.value, __AnnotationRef.set, None, '\n        The AnnotationRef element is a reference to an element derived\n        from the CommonAnnotation element.\n      ')

    
    # Attribute Manufacturer inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}ManufacturerSpec
    
    # Attribute Model inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}ManufacturerSpec
    
    # Attribute SerialNumber inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}ManufacturerSpec
    
    # Attribute LotNumber inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}ManufacturerSpec
    
    # Attribute ID uses Python identifier ID
    __ID = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'ID'), 'ID', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_33_ID', _module_typeBindings.DichroicID, required=True)
    __ID._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2406, 10)
    __ID._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2406, 10)
    
    ID = property(__ID.value, __ID.set, None, None)

    _ElementMap.update({
        __AnnotationRef.name() : __AnnotationRef
    })
    _AttributeMap.update({
        __ID.name() : __ID
    })
_module_typeBindings.CTD_ANON_33 = CTD_ANON_33


# Complex type [anonymous] with content type EMPTY
class CTD_ANON_34 (Reference):
    """Complex type [anonymous] with content type EMPTY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_EMPTY
    _Abstract = False
    _ExpandedName = None
    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2444, 4)
    _ElementMap = Reference._ElementMap.copy()
    _AttributeMap = Reference._AttributeMap.copy()
    # Base type is Reference
    
    # Attribute ID uses Python identifier ID
    __ID = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'ID'), 'ID', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_34_ID', _module_typeBindings.DichroicID, required=True)
    __ID._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2447, 10)
    __ID._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2447, 10)
    
    ID = property(__ID.value, __ID.set, None, None)

    _ElementMap.update({
        
    })
    _AttributeMap.update({
        __ID.name() : __ID
    })
_module_typeBindings.CTD_ANON_34 = CTD_ANON_34


# Complex type {http://www.openmicroscopy.org/Schemas/OME/2016-06}LightSource with content type ELEMENT_ONLY
class LightSource (ManufacturerSpec):
    """
        The lightsource for the instrument.  An instrument may have several light sources.
        The type of lightsource is specified by one of the child-elements which are 'Laser', 'Filament', 'Arc' or 'LightEmittingDiode'.
        Each of the light source types has its own Type attribute to further differentiate the light source
        (eg, Nd-YAG for Laser or Hg for Arc).
      """
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'LightSource')
    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2455, 2)
    _ElementMap = ManufacturerSpec._ElementMap.copy()
    _AttributeMap = ManufacturerSpec._AttributeMap.copy()
    # Base type is ManufacturerSpec
    
    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}AnnotationRef uses Python identifier AnnotationRef
    __AnnotationRef = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'AnnotationRef'), 'AnnotationRef', '__httpwww_openmicroscopy_orgSchemasOME2016_06_LightSource_httpwww_openmicroscopy_orgSchemasOME2016_06AnnotationRef', True, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3435, 2), )

    
    AnnotationRef = property(__AnnotationRef.value, __AnnotationRef.set, None, '\n        The AnnotationRef element is a reference to an element derived\n        from the CommonAnnotation element.\n      ')

    
    # Attribute Manufacturer inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}ManufacturerSpec
    
    # Attribute Model inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}ManufacturerSpec
    
    # Attribute SerialNumber inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}ManufacturerSpec
    
    # Attribute LotNumber inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}ManufacturerSpec
    
    # Attribute ID uses Python identifier ID
    __ID = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'ID'), 'ID', '__httpwww_openmicroscopy_orgSchemasOME2016_06_LightSource_ID', _module_typeBindings.LightSourceID, required=True)
    __ID._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2474, 8)
    __ID._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2474, 8)
    
    ID = property(__ID.value, __ID.set, None, '\n              A LightSource ID must be specified for each light source, and the individual\n              light sources can be referred to by their LightSource IDs (eg from Channel).\n            ')

    
    # Attribute Power uses Python identifier Power
    __Power = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'Power'), 'Power', '__httpwww_openmicroscopy_orgSchemasOME2016_06_LightSource_Power', pyxb.binding.datatypes.float)
    __Power._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2482, 8)
    __Power._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2482, 8)
    
    Power = property(__Power.value, __Power.set, None, '\n              The light-source power. Units are set by PowerUnit.\n            ')

    
    # Attribute PowerUnit uses Python identifier PowerUnit
    __PowerUnit = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'PowerUnit'), 'PowerUnit', '__httpwww_openmicroscopy_orgSchemasOME2016_06_LightSource_PowerUnit', _module_typeBindings.UnitsPower, unicode_default='mW')
    __PowerUnit._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2489, 8)
    __PowerUnit._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2489, 8)
    
    PowerUnit = property(__PowerUnit.value, __PowerUnit.set, None, 'The units of the Power - default:milliwatts[mW].')

    _ElementMap.update({
        __AnnotationRef.name() : __AnnotationRef
    })
    _AttributeMap.update({
        __ID.name() : __ID,
        __Power.name() : __Power,
        __PowerUnit.name() : __PowerUnit
    })
_module_typeBindings.LightSource = LightSource
Namespace.addCategoryObject('typeBinding', 'LightSource', LightSource)


# Complex type [anonymous] with content type EMPTY
class CTD_ANON_35 (Reference):
    """
        The Pump element is a reference to a LightSource.  It is used within the Laser element to specify the light source for the laser's pump (if any).
      """
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_EMPTY
    _Abstract = False
    _ExpandedName = None
    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2785, 4)
    _ElementMap = Reference._ElementMap.copy()
    _AttributeMap = Reference._AttributeMap.copy()
    # Base type is Reference
    
    # Attribute ID uses Python identifier ID
    __ID = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'ID'), 'ID', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_35_ID', _module_typeBindings.LightSourceID, required=True)
    __ID._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2788, 10)
    __ID._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2788, 10)
    
    ID = property(__ID.value, __ID.set, None, None)

    _ElementMap.update({
        
    })
    _AttributeMap.update({
        __ID.name() : __ID
    })
_module_typeBindings.CTD_ANON_35 = CTD_ANON_35


# Complex type [anonymous] with content type EMPTY
class CTD_ANON_36 (Reference):
    """
        The ImageRef element is a reference to an Image element.
      """
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_EMPTY
    _Abstract = False
    _ExpandedName = None
    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2850, 4)
    _ElementMap = Reference._ElementMap.copy()
    _AttributeMap = Reference._AttributeMap.copy()
    # Base type is Reference
    
    # Attribute ID uses Python identifier ID
    __ID = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'ID'), 'ID', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_36_ID', _module_typeBindings.ImageID, required=True)
    __ID._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2853, 10)
    __ID._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2853, 10)
    
    ID = property(__ID.value, __ID.set, None, None)

    _ElementMap.update({
        
    })
    _AttributeMap.update({
        __ID.name() : __ID
    })
_module_typeBindings.CTD_ANON_36 = CTD_ANON_36


# Complex type {http://www.openmicroscopy.org/Schemas/OME/2016-06}FilterRef with content type EMPTY
class FilterRef (Reference):
    """Complex type {http://www.openmicroscopy.org/Schemas/OME/2016-06}FilterRef with content type EMPTY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_EMPTY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'FilterRef')
    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2859, 2)
    _ElementMap = Reference._ElementMap.copy()
    _AttributeMap = Reference._AttributeMap.copy()
    # Base type is Reference
    
    # Attribute ID uses Python identifier ID
    __ID = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'ID'), 'ID', '__httpwww_openmicroscopy_orgSchemasOME2016_06_FilterRef_ID', _module_typeBindings.FilterID, required=True)
    __ID._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2862, 8)
    __ID._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2862, 8)
    
    ID = property(__ID.value, __ID.set, None, None)

    _ElementMap.update({
        
    })
    _AttributeMap.update({
        __ID.name() : __ID
    })
_module_typeBindings.FilterRef = FilterRef
Namespace.addCategoryObject('typeBinding', 'FilterRef', FilterRef)


# Complex type [anonymous] with content type EMPTY
class CTD_ANON_37 (Reference):
    """Complex type [anonymous] with content type EMPTY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_EMPTY
    _Abstract = False
    _ExpandedName = None
    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2868, 4)
    _ElementMap = Reference._ElementMap.copy()
    _AttributeMap = Reference._AttributeMap.copy()
    # Base type is Reference
    
    # Attribute ID uses Python identifier ID
    __ID = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'ID'), 'ID', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_37_ID', _module_typeBindings.MicrobeamManipulationID, required=True)
    __ID._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2871, 10)
    __ID._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2871, 10)
    
    ID = property(__ID.value, __ID.set, None, None)

    _ElementMap.update({
        
    })
    _AttributeMap.update({
        __ID.name() : __ID
    })
_module_typeBindings.CTD_ANON_37 = CTD_ANON_37


# Complex type [anonymous] with content type EMPTY
class CTD_ANON_38 (Reference):
    """Complex type [anonymous] with content type EMPTY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_EMPTY
    _Abstract = False
    _ExpandedName = None
    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2877, 4)
    _ElementMap = Reference._ElementMap.copy()
    _AttributeMap = Reference._AttributeMap.copy()
    # Base type is Reference
    
    # Attribute ID uses Python identifier ID
    __ID = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'ID'), 'ID', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_38_ID', _module_typeBindings.ExperimentID, required=True)
    __ID._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2880, 10)
    __ID._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2880, 10)
    
    ID = property(__ID.value, __ID.set, None, None)

    _ElementMap.update({
        
    })
    _AttributeMap.update({
        __ID.name() : __ID
    })
_module_typeBindings.CTD_ANON_38 = CTD_ANON_38


# Complex type [anonymous] with content type EMPTY
class CTD_ANON_39 (Reference):
    """Complex type [anonymous] with content type EMPTY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_EMPTY
    _Abstract = False
    _ExpandedName = None
    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2886, 4)
    _ElementMap = Reference._ElementMap.copy()
    _AttributeMap = Reference._AttributeMap.copy()
    # Base type is Reference
    
    # Attribute ID uses Python identifier ID
    __ID = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'ID'), 'ID', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_39_ID', _module_typeBindings.ChannelID, required=True)
    __ID._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2889, 10)
    __ID._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2889, 10)
    
    ID = property(__ID.value, __ID.set, None, None)

    _ElementMap.update({
        
    })
    _AttributeMap.update({
        __ID.name() : __ID
    })
_module_typeBindings.CTD_ANON_39 = CTD_ANON_39


# Complex type [anonymous] with content type EMPTY
class CTD_ANON_40 (Reference):
    """
        There may be one or more of these in a Dataset.
        This empty element has a required Project ID attribute that refers to Projects defined within the OME element.
      """
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_EMPTY
    _Abstract = False
    _ExpandedName = None
    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2901, 4)
    _ElementMap = Reference._ElementMap.copy()
    _AttributeMap = Reference._AttributeMap.copy()
    # Base type is Reference
    
    # Attribute ID uses Python identifier ID
    __ID = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'ID'), 'ID', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_40_ID', _module_typeBindings.ProjectID, required=True)
    __ID._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2904, 10)
    __ID._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2904, 10)
    
    ID = property(__ID.value, __ID.set, None, None)

    _ElementMap.update({
        
    })
    _AttributeMap.update({
        __ID.name() : __ID
    })
_module_typeBindings.CTD_ANON_40 = CTD_ANON_40


# Complex type [anonymous] with content type EMPTY
class CTD_ANON_41 (Reference):
    """
        This empty element has a required Experimenter ID and an optional DocumentID attribute which refers to one of the Experimenters defined within OME.
      """
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_EMPTY
    _Abstract = False
    _ExpandedName = None
    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2915, 4)
    _ElementMap = Reference._ElementMap.copy()
    _AttributeMap = Reference._AttributeMap.copy()
    # Base type is Reference
    
    # Attribute ID uses Python identifier ID
    __ID = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'ID'), 'ID', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_41_ID', _module_typeBindings.ExperimenterID, required=True)
    __ID._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2918, 10)
    __ID._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2918, 10)
    
    ID = property(__ID.value, __ID.set, None, None)

    _ElementMap.update({
        
    })
    _AttributeMap.update({
        __ID.name() : __ID
    })
_module_typeBindings.CTD_ANON_41 = CTD_ANON_41


# Complex type [anonymous] with content type EMPTY
class CTD_ANON_42 (Reference):
    """This empty element has a reference (the ExperimenterGroup ID attribute) to a ExperimenterGroup defined within OME."""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_EMPTY
    _Abstract = False
    _ExpandedName = None
    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2927, 4)
    _ElementMap = Reference._ElementMap.copy()
    _AttributeMap = Reference._AttributeMap.copy()
    # Base type is Reference
    
    # Attribute ID uses Python identifier ID
    __ID = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'ID'), 'ID', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_42_ID', _module_typeBindings.ExperimenterGroupID, required=True)
    __ID._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2930, 10)
    __ID._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2930, 10)
    
    ID = property(__ID.value, __ID.set, None, None)

    _ElementMap.update({
        
    })
    _AttributeMap.update({
        __ID.name() : __ID
    })
_module_typeBindings.CTD_ANON_42 = CTD_ANON_42


# Complex type [anonymous] with content type EMPTY
class CTD_ANON_43 (Reference):
    """
        This empty element can be used (via the required Instrument ID attribute) to refer to an Instrument defined within OME.
      """
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_EMPTY
    _Abstract = False
    _ExpandedName = None
    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2941, 4)
    _ElementMap = Reference._ElementMap.copy()
    _AttributeMap = Reference._AttributeMap.copy()
    # Base type is Reference
    
    # Attribute ID uses Python identifier ID
    __ID = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'ID'), 'ID', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_43_ID', _module_typeBindings.InstrumentID, required=True)
    __ID._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2944, 10)
    __ID._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2944, 10)
    
    ID = property(__ID.value, __ID.set, None, None)

    _ElementMap.update({
        
    })
    _AttributeMap.update({
        __ID.name() : __ID
    })
_module_typeBindings.CTD_ANON_43 = CTD_ANON_43


# Complex type [anonymous] with content type EMPTY
class CTD_ANON_44 (Reference):
    """
        The DatasetRef element refers to a Dataset by specifying the Dataset ID attribute.
        One or more DatasetRef elements may be listed within the Image element to specify what Datasets
        the Image belongs to.
      """
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_EMPTY
    _Abstract = False
    _ExpandedName = None
    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2957, 4)
    _ElementMap = Reference._ElementMap.copy()
    _AttributeMap = Reference._AttributeMap.copy()
    # Base type is Reference
    
    # Attribute ID uses Python identifier ID
    __ID = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'ID'), 'ID', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_44_ID', _module_typeBindings.DatasetID, required=True)
    __ID._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2960, 10)
    __ID._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2960, 10)
    
    ID = property(__ID.value, __ID.set, None, None)

    _ElementMap.update({
        
    })
    _AttributeMap.update({
        __ID.name() : __ID
    })
_module_typeBindings.CTD_ANON_44 = CTD_ANON_44


# Complex type [anonymous] with content type EMPTY
class CTD_ANON_45 (Reference):
    """
        The FolderRef element refers to a Folder by specifying the Folder ID attribute.
        One or more FolderRef elements may be listed within the Folder element to specify what Folders
        the Folder contains. This tree hierarchy must be acyclic.
      """
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_EMPTY
    _Abstract = False
    _ExpandedName = None
    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2973, 4)
    _ElementMap = Reference._ElementMap.copy()
    _AttributeMap = Reference._AttributeMap.copy()
    # Base type is Reference
    
    # Attribute ID uses Python identifier ID
    __ID = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'ID'), 'ID', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_45_ID', _module_typeBindings.FolderID, required=True)
    __ID._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2976, 10)
    __ID._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2976, 10)
    
    ID = property(__ID.value, __ID.set, None, None)

    _ElementMap.update({
        
    })
    _AttributeMap.update({
        __ID.name() : __ID
    })
_module_typeBindings.CTD_ANON_45 = CTD_ANON_45


# Complex type [anonymous] with content type EMPTY
class CTD_ANON_46 (Reference):
    """Complex type [anonymous] with content type EMPTY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_EMPTY
    _Abstract = False
    _ExpandedName = None
    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2982, 4)
    _ElementMap = Reference._ElementMap.copy()
    _AttributeMap = Reference._AttributeMap.copy()
    # Base type is Reference
    
    # Attribute ID uses Python identifier ID
    __ID = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'ID'), 'ID', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_46_ID', _module_typeBindings.FilterSetID, required=True)
    __ID._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2985, 10)
    __ID._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2985, 10)
    
    ID = property(__ID.value, __ID.set, None, None)

    _ElementMap.update({
        
    })
    _AttributeMap.update({
        __ID.name() : __ID
    })
_module_typeBindings.CTD_ANON_46 = CTD_ANON_46


# Complex type [anonymous] with content type EMPTY
class CTD_ANON_47 (Settings):
    """"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_EMPTY
    _Abstract = False
    _ExpandedName = None
    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3010, 4)
    _ElementMap = Settings._ElementMap.copy()
    _AttributeMap = Settings._AttributeMap.copy()
    # Base type is Settings
    
    # Attribute ID uses Python identifier ID
    __ID = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'ID'), 'ID', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_47_ID', _module_typeBindings.LightSourceID, required=True)
    __ID._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3013, 10)
    __ID._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3013, 10)
    
    ID = property(__ID.value, __ID.set, None, None)

    
    # Attribute Attenuation uses Python identifier Attenuation
    __Attenuation = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'Attenuation'), 'Attenuation', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_47_Attenuation', _module_typeBindings.PercentFraction)
    __Attenuation._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3014, 10)
    __Attenuation._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3014, 10)
    
    Attenuation = property(__Attenuation.value, __Attenuation.set, None, '\n                The Attenuation of the light source [units:none]\n                A fraction, as a value from 0.0 to 1.0.\n              ')

    
    # Attribute Wavelength uses Python identifier Wavelength
    __Wavelength = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'Wavelength'), 'Wavelength', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_47_Wavelength', _module_typeBindings.PositiveFloat)
    __Wavelength._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3022, 10)
    __Wavelength._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3022, 10)
    
    Wavelength = property(__Wavelength.value, __Wavelength.set, None, '\n                The Wavelength of the light source. Units are set by WavelengthUnit.\n              ')

    
    # Attribute WavelengthUnit uses Python identifier WavelengthUnit
    __WavelengthUnit = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'WavelengthUnit'), 'WavelengthUnit', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_47_WavelengthUnit', _module_typeBindings.UnitsLength, unicode_default='nm')
    __WavelengthUnit._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3029, 10)
    __WavelengthUnit._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3029, 10)
    
    WavelengthUnit = property(__WavelengthUnit.value, __WavelengthUnit.set, None, '\n                The units of the Wavelength of the light source - default:nanometres[nm]\n              ')

    _ElementMap.update({
        
    })
    _AttributeMap.update({
        __ID.name() : __ID,
        __Attenuation.name() : __Attenuation,
        __Wavelength.name() : __Wavelength,
        __WavelengthUnit.name() : __WavelengthUnit
    })
_module_typeBindings.CTD_ANON_47 = CTD_ANON_47


# Complex type [anonymous] with content type EMPTY
class CTD_ANON_48 (Settings):
    """
        This holds the setting applied to a detector as well as a
        reference to the detector.
        The ID is the detector used in this case.
        The values stored in DetectorSettings represent the variable values,
        fixed values not modified during the acquisition go in Detector.

        Each attribute now has an indication of what type of detector
        it applies to. This is preparatory work for cleaning up and
        possibly splitting this object into sub-types.
      """
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_EMPTY
    _Abstract = False
    _ExpandedName = None
    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3055, 4)
    _ElementMap = Settings._ElementMap.copy()
    _AttributeMap = Settings._AttributeMap.copy()
    # Base type is Settings
    
    # Attribute ID uses Python identifier ID
    __ID = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'ID'), 'ID', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_48_ID', _module_typeBindings.DetectorID, required=True)
    __ID._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3058, 10)
    __ID._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3058, 10)
    
    ID = property(__ID.value, __ID.set, None, None)

    
    # Attribute Offset uses Python identifier Offset
    __Offset = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'Offset'), 'Offset', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_48_Offset', pyxb.binding.datatypes.float)
    __Offset._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3059, 10)
    __Offset._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3059, 10)
    
    Offset = property(__Offset.value, __Offset.set, None, '\n                The Offset of the detector. [units none] {used:CCD,EMCCD}\n              ')

    
    # Attribute Gain uses Python identifier Gain
    __Gain = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'Gain'), 'Gain', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_48_Gain', pyxb.binding.datatypes.float)
    __Gain._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3066, 10)
    __Gain._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3066, 10)
    
    Gain = property(__Gain.value, __Gain.set, None, '\n                The Gain of the detector. [units:none] {used:CCD,EMCCD,PMT}\n              ')

    
    # Attribute Voltage uses Python identifier Voltage
    __Voltage = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'Voltage'), 'Voltage', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_48_Voltage', pyxb.binding.datatypes.float)
    __Voltage._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3073, 10)
    __Voltage._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3073, 10)
    
    Voltage = property(__Voltage.value, __Voltage.set, None, '\n                The Voltage of the detector. {used:PMT}\n                Units are set by VoltageUnit.\n              ')

    
    # Attribute VoltageUnit uses Python identifier VoltageUnit
    __VoltageUnit = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'VoltageUnit'), 'VoltageUnit', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_48_VoltageUnit', _module_typeBindings.UnitsElectricPotential, unicode_default='V')
    __VoltageUnit._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3081, 10)
    __VoltageUnit._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3081, 10)
    
    VoltageUnit = property(__VoltageUnit.value, __VoltageUnit.set, None, '\n                The units of the Voltage of the detector - default:volts[V]\n              ')

    
    # Attribute Zoom uses Python identifier Zoom
    __Zoom = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'Zoom'), 'Zoom', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_48_Zoom', pyxb.binding.datatypes.float)
    __Zoom._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3088, 10)
    __Zoom._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3088, 10)
    
    Zoom = property(__Zoom.value, __Zoom.set, None, '\n                The Zoom or "Confocal Zoom" or "Scan Zoom" for a detector. [units:none] {used:PMT}\n              ')

    
    # Attribute ReadOutRate uses Python identifier ReadOutRate
    __ReadOutRate = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'ReadOutRate'), 'ReadOutRate', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_48_ReadOutRate', pyxb.binding.datatypes.float)
    __ReadOutRate._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3095, 10)
    __ReadOutRate._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3095, 10)
    
    ReadOutRate = property(__ReadOutRate.value, __ReadOutRate.set, None, '\n                The speed at which the detector can count pixels.  {used:CCD,EMCCD}\n                This is the bytes per second that\n                can be read from the detector (like a baud rate).\n                Units are set by ReadOutRateUnit.\n              ')

    
    # Attribute ReadOutRateUnit uses Python identifier ReadOutRateUnit
    __ReadOutRateUnit = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'ReadOutRateUnit'), 'ReadOutRateUnit', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_48_ReadOutRateUnit', _module_typeBindings.UnitsFrequency, unicode_default='MHz')
    __ReadOutRateUnit._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3105, 10)
    __ReadOutRateUnit._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3105, 10)
    
    ReadOutRateUnit = property(__ReadOutRateUnit.value, __ReadOutRateUnit.set, None, 'The units of the ReadOutRate - default:megahertz[Hz].')

    
    # Attribute Binning uses Python identifier Binning
    __Binning = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'Binning'), 'Binning', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_48_Binning', _module_typeBindings.Binning)
    __Binning._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3110, 10)
    __Binning._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3110, 10)
    
    Binning = property(__Binning.value, __Binning.set, None, '\n                Represents the number of pixels that are combined to form larger pixels. {used:CCD,EMCCD}\n              ')

    
    # Attribute Integration uses Python identifier Integration
    __Integration = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'Integration'), 'Integration', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_48_Integration', _module_typeBindings.PositiveInt)
    __Integration._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3117, 10)
    __Integration._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3117, 10)
    
    Integration = property(__Integration.value, __Integration.set, None, '\n                This is the number of sequential frames that get averaged,\n                to improve the signal-to-noise ratio. [units:none] {used:CCD,EMCCD}\n              ')

    _ElementMap.update({
        
    })
    _AttributeMap.update({
        __ID.name() : __ID,
        __Offset.name() : __Offset,
        __Gain.name() : __Gain,
        __Voltage.name() : __Voltage,
        __VoltageUnit.name() : __VoltageUnit,
        __Zoom.name() : __Zoom,
        __ReadOutRate.name() : __ReadOutRate,
        __ReadOutRateUnit.name() : __ReadOutRateUnit,
        __Binning.name() : __Binning,
        __Integration.name() : __Integration
    })
_module_typeBindings.CTD_ANON_48 = CTD_ANON_48


# Complex type [anonymous] with content type EMPTY
class CTD_ANON_49 (Settings):
    """
        This holds the setting applied to an objective as well as a
        reference to the objective.
        The ID is the objective used in this case.
      """
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_EMPTY
    _Abstract = False
    _ExpandedName = None
    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3138, 4)
    _ElementMap = Settings._ElementMap.copy()
    _AttributeMap = Settings._AttributeMap.copy()
    # Base type is Settings
    
    # Attribute ID uses Python identifier ID
    __ID = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'ID'), 'ID', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_49_ID', _module_typeBindings.ObjectiveID, required=True)
    __ID._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3141, 10)
    __ID._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3141, 10)
    
    ID = property(__ID.value, __ID.set, None, None)

    
    # Attribute CorrectionCollar uses Python identifier CorrectionCollar
    __CorrectionCollar = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'CorrectionCollar'), 'CorrectionCollar', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_49_CorrectionCollar', pyxb.binding.datatypes.float)
    __CorrectionCollar._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3142, 10)
    __CorrectionCollar._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3142, 10)
    
    CorrectionCollar = property(__CorrectionCollar.value, __CorrectionCollar.set, None, '\n                The CorrectionCollar is normally an adjustable ring on the\n                objective. Each has an arbitrary scale on it so the values\n                is unit-less. [units:none]\n              ')

    
    # Attribute Medium uses Python identifier Medium
    __Medium = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'Medium'), 'Medium', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_49_Medium', _module_typeBindings.STD_ANON_25)
    __Medium._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3151, 10)
    __Medium._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3151, 10)
    
    Medium = property(__Medium.value, __Medium.set, None, None)

    
    # Attribute RefractiveIndex uses Python identifier RefractiveIndex
    __RefractiveIndex = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'RefractiveIndex'), 'RefractiveIndex', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_49_RefractiveIndex', pyxb.binding.datatypes.float)
    __RefractiveIndex._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3168, 10)
    __RefractiveIndex._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3168, 10)
    
    RefractiveIndex = property(__RefractiveIndex.value, __RefractiveIndex.set, None, '\n                The RefractiveIndex is that of the immersion medium. This is\n                a ratio so it also unit-less. [units:none]\n              ')

    _ElementMap.update({
        
    })
    _AttributeMap.update({
        __ID.name() : __ID,
        __CorrectionCollar.name() : __CorrectionCollar,
        __Medium.name() : __Medium,
        __RefractiveIndex.name() : __RefractiveIndex
    })
_module_typeBindings.CTD_ANON_49 = CTD_ANON_49


# Complex type [anonymous] with content type SIMPLE
class CTD_ANON_50 (pyxb.binding.basis.complexTypeDefinition):
    """The contents of this element are base64-encoded.  These are not CDATA sections, just a base64 stream."""
    _TypeDefinition = base64Binary
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_SIMPLE
    _Abstract = False
    _ExpandedName = None
    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3325, 4)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is base64Binary
    
    # Attribute Compression uses Python identifier Compression
    __Compression = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'Compression'), 'Compression', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_50_Compression', _module_typeBindings.STD_ANON_27, unicode_default='none')
    __Compression._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3328, 10)
    __Compression._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3328, 10)
    
    Compression = property(__Compression.value, __Compression.set, None, 'Specifies the compression scheme used to encode the data. ')

    
    # Attribute BigEndian uses Python identifier BigEndian
    __BigEndian = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'BigEndian'), 'BigEndian', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_50_BigEndian', pyxb.binding.datatypes.boolean, required=True)
    __BigEndian._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3340, 10)
    __BigEndian._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3340, 10)
    
    BigEndian = property(__BigEndian.value, __BigEndian.set, None, '\n                This is true if the binary data was written in BigEndian order. This is dependent on the system architecture of the machine that wrote the pixels. True for essentially all modern CPUs other than Intel and Alpha. All Binary data must be written in the same endian order.\n              ')

    
    # Attribute Length uses Python identifier Length
    __Length = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'Length'), 'Length', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_50_Length', _module_typeBindings.STD_ANON_39, required=True)
    __Length._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3347, 10)
    __Length._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3347, 10)
    
    Length = property(__Length.value, __Length.set, None, '\n                Character count attribute for the BinData field. This is the length of the base-64 encoded block. It allows easy skipping of the block when parsing the file. [unit:bytes]\n              ')

    _ElementMap.update({
        
    })
    _AttributeMap.update({
        __Compression.name() : __Compression,
        __BigEndian.name() : __BigEndian,
        __Length.name() : __Length
    })
_module_typeBindings.CTD_ANON_50 = CTD_ANON_50


# Complex type [anonymous] with content type EMPTY
class CTD_ANON_51 (Reference):
    """
        The AnnotationRef element is a reference to an element derived
        from the CommonAnnotation element.
      """
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_EMPTY
    _Abstract = False
    _ExpandedName = None
    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3442, 4)
    _ElementMap = Reference._ElementMap.copy()
    _AttributeMap = Reference._AttributeMap.copy()
    # Base type is Reference
    
    # Attribute ID uses Python identifier ID
    __ID = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'ID'), 'ID', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_51_ID', _module_typeBindings.AnnotationID, required=True)
    __ID._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3445, 10)
    __ID._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3445, 10)
    
    ID = property(__ID.value, __ID.set, None, None)

    _ElementMap.update({
        
    })
    _AttributeMap.update({
        __ID.name() : __ID
    })
_module_typeBindings.CTD_ANON_51 = CTD_ANON_51


# Complex type {http://www.openmicroscopy.org/Schemas/OME/2016-06}Annotation with content type ELEMENT_ONLY
class Annotation (pyxb.binding.basis.complexTypeDefinition):
    """
        An annotation from which all others are ultimately derived.
      """
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'Annotation')
    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3452, 2)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}AnnotationRef uses Python identifier AnnotationRef
    __AnnotationRef = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'AnnotationRef'), 'AnnotationRef', '__httpwww_openmicroscopy_orgSchemasOME2016_06_Annotation_httpwww_openmicroscopy_orgSchemasOME2016_06AnnotationRef', True, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3435, 2), )

    
    AnnotationRef = property(__AnnotationRef.value, __AnnotationRef.set, None, '\n        The AnnotationRef element is a reference to an element derived\n        from the CommonAnnotation element.\n      ')

    
    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}Description uses Python identifier Description
    __Description = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'Description'), 'Description', '__httpwww_openmicroscopy_orgSchemasOME2016_06_Annotation_httpwww_openmicroscopy_orgSchemasOME2016_06Description', False, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3460, 6), )

    
    Description = property(__Description.value, __Description.set, None, '\n            A description for the annotation. [plain-text multi-line string]\n          ')

    
    # Attribute ID uses Python identifier ID
    __ID = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'ID'), 'ID', '__httpwww_openmicroscopy_orgSchemasOME2016_06_Annotation_ID', _module_typeBindings.AnnotationID, required=True)
    __ID._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3480, 4)
    __ID._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3480, 4)
    
    ID = property(__ID.value, __ID.set, None, None)

    
    # Attribute Namespace uses Python identifier Namespace_
    __Namespace = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'Namespace'), 'Namespace_', '__httpwww_openmicroscopy_orgSchemasOME2016_06_Annotation_Namespace', pyxb.binding.datatypes.anyURI)
    __Namespace._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3481, 4)
    __Namespace._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3481, 4)
    
    Namespace_ = property(__Namespace.value, __Namespace.set, None, "\n          We recommend the inclusion of a namespace for annotations you\n          define. If it is absent then we assume the annotation is to\n          use our (OME's) default interpretation for this type.\n        ")

    
    # Attribute Annotator uses Python identifier Annotator
    __Annotator = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'Annotator'), 'Annotator', '__httpwww_openmicroscopy_orgSchemasOME2016_06_Annotation_Annotator', _module_typeBindings.ExperimenterID)
    __Annotator._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3490, 4)
    __Annotator._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3490, 4)
    
    Annotator = property(__Annotator.value, __Annotator.set, None, '\n          The Annotator is the person who attached this annotation.\n          e.g. If UserA annotates something with TagB, owned by UserB,\n          UserA is still the Annotator.\n        ')

    _ElementMap.update({
        __AnnotationRef.name() : __AnnotationRef,
        __Description.name() : __Description
    })
    _AttributeMap.update({
        __ID.name() : __ID,
        __Namespace.name() : __Namespace,
        __Annotator.name() : __Annotator
    })
_module_typeBindings.Annotation = Annotation
Namespace.addCategoryObject('typeBinding', 'Annotation', Annotation)


# Complex type [anonymous] with content type ELEMENT_ONLY
class CTD_ANON_52 (pyxb.binding.basis.complexTypeDefinition):
    """
        A four dimensional 'Region of Interest'.
        If they are not used, and the Image has more than one plane,
        the entire set of planes is assumed to be included in the ROI.
        Multiple ROIs may be specified.
      """
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = None
    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3756, 4)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}AnnotationRef uses Python identifier AnnotationRef
    __AnnotationRef = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'AnnotationRef'), 'AnnotationRef', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_52_httpwww_openmicroscopy_orgSchemasOME2016_06AnnotationRef', True, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3435, 2), )

    
    AnnotationRef = property(__AnnotationRef.value, __AnnotationRef.set, None, '\n        The AnnotationRef element is a reference to an element derived\n        from the CommonAnnotation element.\n      ')

    
    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}Union uses Python identifier Union
    __Union = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'Union'), 'Union', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_52_httpwww_openmicroscopy_orgSchemasOME2016_06Union', False, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3759, 10), )

    
    Union = property(__Union.value, __Union.set, None, None)

    
    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}Description uses Python identifier Description
    __Description = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'Description'), 'Description', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_52_httpwww_openmicroscopy_orgSchemasOME2016_06Description', False, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3772, 8), )

    
    Description = property(__Description.value, __Description.set, None, '\n              A description for the ROI. [plain-text multi-line string]\n            ')

    
    # Attribute ID uses Python identifier ID
    __ID = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'ID'), 'ID', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_52_ID', _module_typeBindings.ROIID, required=True)
    __ID._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3785, 6)
    __ID._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3785, 6)
    
    ID = property(__ID.value, __ID.set, None, None)

    
    # Attribute Name uses Python identifier Name
    __Name = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'Name'), 'Name', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_52_Name', pyxb.binding.datatypes.string)
    __Name._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3786, 6)
    __Name._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3786, 6)
    
    Name = property(__Name.value, __Name.set, None, '\n            The Name identifies the ROI to the user. [plain-text string]\n          ')

    _ElementMap.update({
        __AnnotationRef.name() : __AnnotationRef,
        __Union.name() : __Union,
        __Description.name() : __Description
    })
    _AttributeMap.update({
        __ID.name() : __ID,
        __Name.name() : __Name
    })
_module_typeBindings.CTD_ANON_52 = CTD_ANON_52


# Complex type {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape with content type ELEMENT_ONLY
class Shape (pyxb.binding.basis.complexTypeDefinition):
    """
        The shape element contains a single specific ROI shape and links
        that to any channels, and a timepoint and a z-section. It also
        records any transform applied to the ROI shape.
      """
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'Shape')
    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3796, 2)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}AnnotationRef uses Python identifier AnnotationRef
    __AnnotationRef = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'AnnotationRef'), 'AnnotationRef', '__httpwww_openmicroscopy_orgSchemasOME2016_06_Shape_httpwww_openmicroscopy_orgSchemasOME2016_06AnnotationRef', True, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3435, 2), )

    
    AnnotationRef = property(__AnnotationRef.value, __AnnotationRef.set, None, '\n        The AnnotationRef element is a reference to an element derived\n        from the CommonAnnotation element.\n      ')

    
    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}Transform uses Python identifier Transform
    __Transform = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'Transform'), 'Transform', '__httpwww_openmicroscopy_orgSchemasOME2016_06_Shape_httpwww_openmicroscopy_orgSchemasOME2016_06Transform', False, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3806, 6), )

    
    Transform = property(__Transform.value, __Transform.set, None, '\n            This is a matrix used to transform the shape.\n            The element has 6 xsd:float attributes. If the element\n            is present then all 6 values must be included.\n          ')

    
    # Attribute FillColor uses Python identifier FillColor
    __FillColor = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'FillColor'), 'FillColor', '__httpwww_openmicroscopy_orgSchemasOME2016_06_Shape_FillColor', _module_typeBindings.Color)
    __FillColor._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3821, 4)
    __FillColor._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3821, 4)
    
    FillColor = property(__FillColor.value, __FillColor.set, None, '\n          The color of the fill - encoded as RGBA\n          The value "-1" is #FFFFFFFF so solid white (it is a signed 32 bit value)\n          NOTE: Prior to the 2012-06 schema the default value was incorrect and produced a transparent red not solid white.\n        ')

    
    # Attribute FillRule uses Python identifier FillRule
    __FillRule = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'FillRule'), 'FillRule', '__httpwww_openmicroscopy_orgSchemasOME2016_06_Shape_FillRule', _module_typeBindings.STD_ANON_30)
    __FillRule._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3830, 4)
    __FillRule._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3830, 4)
    
    FillRule = property(__FillRule.value, __FillRule.set, None, None)

    
    # Attribute StrokeColor uses Python identifier StrokeColor
    __StrokeColor = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'StrokeColor'), 'StrokeColor', '__httpwww_openmicroscopy_orgSchemasOME2016_06_Shape_StrokeColor', _module_typeBindings.Color)
    __StrokeColor._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3844, 4)
    __StrokeColor._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3844, 4)
    
    StrokeColor = property(__StrokeColor.value, __StrokeColor.set, None, '\n          The color of the stroke  - encoded as RGBA\n          The value "-1" is #FFFFFFFF so solid white (it is a signed 32 bit value)\n          NOTE: Prior to the 2012-06 schema the default value was incorrect and produced a transparent red not solid white.\n        ')

    
    # Attribute StrokeWidth uses Python identifier StrokeWidth
    __StrokeWidth = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'StrokeWidth'), 'StrokeWidth', '__httpwww_openmicroscopy_orgSchemasOME2016_06_Shape_StrokeWidth', pyxb.binding.datatypes.float)
    __StrokeWidth._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3853, 4)
    __StrokeWidth._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3853, 4)
    
    StrokeWidth = property(__StrokeWidth.value, __StrokeWidth.set, None, '\n          The width of the stroke. Units are set by StrokeWidthUnit.\n        ')

    
    # Attribute StrokeWidthUnit uses Python identifier StrokeWidthUnit
    __StrokeWidthUnit = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'StrokeWidthUnit'), 'StrokeWidthUnit', '__httpwww_openmicroscopy_orgSchemasOME2016_06_Shape_StrokeWidthUnit', _module_typeBindings.UnitsLength, unicode_default='pixel')
    __StrokeWidthUnit._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3860, 4)
    __StrokeWidthUnit._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3860, 4)
    
    StrokeWidthUnit = property(__StrokeWidthUnit.value, __StrokeWidthUnit.set, None, '\n          The units used for the stroke width.\n        ')

    
    # Attribute StrokeDashArray uses Python identifier StrokeDashArray
    __StrokeDashArray = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'StrokeDashArray'), 'StrokeDashArray', '__httpwww_openmicroscopy_orgSchemasOME2016_06_Shape_StrokeDashArray', pyxb.binding.datatypes.string)
    __StrokeDashArray._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3867, 4)
    __StrokeDashArray._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3867, 4)
    
    StrokeDashArray = property(__StrokeDashArray.value, __StrokeDashArray.set, None, '\n          e.g. "none", "10 20 30 10"\n        ')

    
    # Attribute Text uses Python identifier Text
    __Text = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'Text'), 'Text', '__httpwww_openmicroscopy_orgSchemasOME2016_06_Shape_Text', pyxb.binding.datatypes.string)
    __Text._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3874, 4)
    __Text._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3874, 4)
    
    Text = property(__Text.value, __Text.set, None, None)

    
    # Attribute FontFamily uses Python identifier FontFamily
    __FontFamily = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'FontFamily'), 'FontFamily', '__httpwww_openmicroscopy_orgSchemasOME2016_06_Shape_FontFamily', _module_typeBindings.STD_ANON_31)
    __FontFamily._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3875, 4)
    __FontFamily._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3875, 4)
    
    FontFamily = property(__FontFamily.value, __FontFamily.set, None, None)

    
    # Attribute FontSize uses Python identifier FontSize
    __FontSize = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'FontSize'), 'FontSize', '__httpwww_openmicroscopy_orgSchemasOME2016_06_Shape_FontSize', _module_typeBindings.NonNegativeInt)
    __FontSize._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3896, 4)
    __FontSize._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3896, 4)
    
    FontSize = property(__FontSize.value, __FontSize.set, None, '\n          Size of the font. Units are set by FontSizeUnit.\n        ')

    
    # Attribute FontSizeUnit uses Python identifier FontSizeUnit
    __FontSizeUnit = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'FontSizeUnit'), 'FontSizeUnit', '__httpwww_openmicroscopy_orgSchemasOME2016_06_Shape_FontSizeUnit', _module_typeBindings.UnitsLength, unicode_default='pt')
    __FontSizeUnit._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3903, 4)
    __FontSizeUnit._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3903, 4)
    
    FontSizeUnit = property(__FontSizeUnit.value, __FontSizeUnit.set, None, '\n          The units used for the font size.\n        ')

    
    # Attribute FontStyle uses Python identifier FontStyle
    __FontStyle = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'FontStyle'), 'FontStyle', '__httpwww_openmicroscopy_orgSchemasOME2016_06_Shape_FontStyle', _module_typeBindings.STD_ANON_32)
    __FontStyle._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3910, 4)
    __FontStyle._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3910, 4)
    
    FontStyle = property(__FontStyle.value, __FontStyle.set, None, None)

    
    # Attribute Locked uses Python identifier Locked
    __Locked = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'Locked'), 'Locked', '__httpwww_openmicroscopy_orgSchemasOME2016_06_Shape_Locked', pyxb.binding.datatypes.boolean)
    __Locked._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3927, 4)
    __Locked._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3927, 4)
    
    Locked = property(__Locked.value, __Locked.set, None, '\n          Controls whether the shape is locked and read only,\n          true is locked, false is editable.\n        ')

    
    # Attribute ID uses Python identifier ID
    __ID = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'ID'), 'ID', '__httpwww_openmicroscopy_orgSchemasOME2016_06_Shape_ID', _module_typeBindings.ShapeID, required=True)
    __ID._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3935, 4)
    __ID._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3935, 4)
    
    ID = property(__ID.value, __ID.set, None, None)

    
    # Attribute TheZ uses Python identifier TheZ
    __TheZ = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'TheZ'), 'TheZ', '__httpwww_openmicroscopy_orgSchemasOME2016_06_Shape_TheZ', _module_typeBindings.NonNegativeInt)
    __TheZ._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3936, 4)
    __TheZ._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3936, 4)
    
    TheZ = property(__TheZ.value, __TheZ.set, None, '\n          The z-section the ROI applies to. If not specified then\n          the ROI applies to all the z-sections of the image. [units:none]\n          This is numbered from 0.\n        ')

    
    # Attribute TheT uses Python identifier TheT
    __TheT = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'TheT'), 'TheT', '__httpwww_openmicroscopy_orgSchemasOME2016_06_Shape_TheT', _module_typeBindings.NonNegativeInt)
    __TheT._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3945, 4)
    __TheT._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3945, 4)
    
    TheT = property(__TheT.value, __TheT.set, None, '\n          The timepoint the ROI applies to. If not specified then\n          the ROI applies to all the timepoints of the image. [units:none]\n          This is numbered from 0.\n        ')

    
    # Attribute TheC uses Python identifier TheC
    __TheC = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'TheC'), 'TheC', '__httpwww_openmicroscopy_orgSchemasOME2016_06_Shape_TheC', _module_typeBindings.NonNegativeInt)
    __TheC._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3954, 4)
    __TheC._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3954, 4)
    
    TheC = property(__TheC.value, __TheC.set, None, '\n          The channel the ROI applies to. If not specified then\n          the ROI applies to all the channels of the image. [units:none]\n          This is numbered from 0.\n        ')

    _ElementMap.update({
        __AnnotationRef.name() : __AnnotationRef,
        __Transform.name() : __Transform
    })
    _AttributeMap.update({
        __FillColor.name() : __FillColor,
        __FillRule.name() : __FillRule,
        __StrokeColor.name() : __StrokeColor,
        __StrokeWidth.name() : __StrokeWidth,
        __StrokeWidthUnit.name() : __StrokeWidthUnit,
        __StrokeDashArray.name() : __StrokeDashArray,
        __Text.name() : __Text,
        __FontFamily.name() : __FontFamily,
        __FontSize.name() : __FontSize,
        __FontSizeUnit.name() : __FontSizeUnit,
        __FontStyle.name() : __FontStyle,
        __Locked.name() : __Locked,
        __ID.name() : __ID,
        __TheZ.name() : __TheZ,
        __TheT.name() : __TheT,
        __TheC.name() : __TheC
    })
_module_typeBindings.Shape = Shape
Namespace.addCategoryObject('typeBinding', 'Shape', Shape)


# Complex type [anonymous] with content type EMPTY
class CTD_ANON_53 (Reference):
    """Complex type [anonymous] with content type EMPTY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_EMPTY
    _Abstract = False
    _ExpandedName = None
    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4248, 4)
    _ElementMap = Reference._ElementMap.copy()
    _AttributeMap = Reference._AttributeMap.copy()
    # Base type is Reference
    
    # Attribute ID uses Python identifier ID
    __ID = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'ID'), 'ID', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_53_ID', _module_typeBindings.ROIID, required=True)
    __ID._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4251, 10)
    __ID._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4251, 10)
    
    ID = property(__ID.value, __ID.set, None, None)

    _ElementMap.update({
        
    })
    _AttributeMap.update({
        __ID.name() : __ID
    })
_module_typeBindings.CTD_ANON_53 = CTD_ANON_53


# Complex type [anonymous] with content type ELEMENT_ONLY
class CTD_ANON_54 (pyxb.binding.basis.complexTypeDefinition):
    """
        This element identifies microtiter plates within a screen.
        A plate can belong to more than one screen.
        The Screen(s) that a plate belongs to are specified by the ScreenRef element.
        The Plate ID and Name attributes are required.
        The Wells in a plate are numbers from the top-left corner in a grid starting at zero.
        i.e. The top-left well of a plate is index (0,0)
      """
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = None
    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4312, 4)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}AnnotationRef uses Python identifier AnnotationRef
    __AnnotationRef = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'AnnotationRef'), 'AnnotationRef', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_54_httpwww_openmicroscopy_orgSchemasOME2016_06AnnotationRef', True, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3435, 2), )

    
    AnnotationRef = property(__AnnotationRef.value, __AnnotationRef.set, None, '\n        The AnnotationRef element is a reference to an element derived\n        from the CommonAnnotation element.\n      ')

    
    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}Description uses Python identifier Description
    __Description = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'Description'), 'Description', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_54_httpwww_openmicroscopy_orgSchemasOME2016_06Description', False, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4314, 8), )

    
    Description = property(__Description.value, __Description.set, None, '\n              A description for the plate.\n            ')

    
    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}PlateAcquisition uses Python identifier PlateAcquisition
    __PlateAcquisition = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'PlateAcquisition'), 'PlateAcquisition', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_54_httpwww_openmicroscopy_orgSchemasOME2016_06PlateAcquisition', True, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4660, 2), )

    
    PlateAcquisition = property(__PlateAcquisition.value, __PlateAcquisition.set, None, '\n        PlateAcquisition is used to describe a single acquisition run for a plate.\n        This object is used to record the set of images acquired in a single\n        acquisition run. The Images for this run are linked to PlateAcquisition\n        through WellSample.\n      ')

    
    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}Well uses Python identifier Well
    __Well = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'Well'), 'Well', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_54_httpwww_openmicroscopy_orgSchemasOME2016_06Well', True, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4726, 2), )

    
    Well = property(__Well.value, __Well.set, None, '\n        A Well is a component of the Well/Plate/Screen construct to describe screening applications.\n        A Well has a number of WellSample elements that link to the Images collected in this well.\n        The ReagentRef links any Reagents that were used in this Well. A well is part of only one Plate.\n        The origin for the row and column identifiers is the top left corner of the plate starting at zero.\n        i.e The top left well of a plate is index (0,0)\n      ')

    
    # Attribute ID uses Python identifier ID
    __ID = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'ID'), 'ID', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_54_ID', _module_typeBindings.PlateID, required=True)
    __ID._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4334, 6)
    __ID._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4334, 6)
    
    ID = property(__ID.value, __ID.set, None, None)

    
    # Attribute Name uses Python identifier Name
    __Name = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'Name'), 'Name', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_54_Name', pyxb.binding.datatypes.string)
    __Name._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4335, 6)
    __Name._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4335, 6)
    
    Name = property(__Name.value, __Name.set, None, '\n            The Name identifies the plate to the user.\n            It is used much like the ID, and so must be\n            unique within the document.\n\n            If a plate name is not available when one is needed\n            it will be constructed in the following order:\n            1. If name is available use it.\n            2. If not use "Start time - End time"\n            (NOTE: Not a subtraction! A string representation\n            of the two times separated by a dash.)\n            3. If these times are not available use the Plate ID.\n          ')

    
    # Attribute Status uses Python identifier Status
    __Status = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'Status'), 'Status', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_54_Status', pyxb.binding.datatypes.string)
    __Status._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4352, 6)
    __Status._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4352, 6)
    
    Status = property(__Status.value, __Status.set, None, '\n            A textual annotation of the current state of the plate with respect to the\n            experiment work-flow; e.g.\n            1. Seed cell: done; 2. Transfection: done;      3. Gel doc: todo.\n          ')

    
    # Attribute ExternalIdentifier uses Python identifier ExternalIdentifier
    __ExternalIdentifier = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'ExternalIdentifier'), 'ExternalIdentifier', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_54_ExternalIdentifier', pyxb.binding.datatypes.string)
    __ExternalIdentifier._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4361, 6)
    __ExternalIdentifier._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4361, 6)
    
    ExternalIdentifier = property(__ExternalIdentifier.value, __ExternalIdentifier.set, None, '\n            The ExternalIdentifier attribute may contain a reference to an external database.\n          ')

    
    # Attribute ColumnNamingConvention uses Python identifier ColumnNamingConvention
    __ColumnNamingConvention = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'ColumnNamingConvention'), 'ColumnNamingConvention', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_54_ColumnNamingConvention', _module_typeBindings.NamingConvention)
    __ColumnNamingConvention._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4368, 6)
    __ColumnNamingConvention._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4368, 6)
    
    ColumnNamingConvention = property(__ColumnNamingConvention.value, __ColumnNamingConvention.set, None, '\n            The ColumnNamingConvention\n          ')

    
    # Attribute RowNamingConvention uses Python identifier RowNamingConvention
    __RowNamingConvention = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'RowNamingConvention'), 'RowNamingConvention', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_54_RowNamingConvention', _module_typeBindings.NamingConvention)
    __RowNamingConvention._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4375, 6)
    __RowNamingConvention._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4375, 6)
    
    RowNamingConvention = property(__RowNamingConvention.value, __RowNamingConvention.set, None, '\n            The RowNamingConvention\n          ')

    
    # Attribute WellOriginX uses Python identifier WellOriginX
    __WellOriginX = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'WellOriginX'), 'WellOriginX', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_54_WellOriginX', pyxb.binding.datatypes.float)
    __WellOriginX._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4382, 6)
    __WellOriginX._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4382, 6)
    
    WellOriginX = property(__WellOriginX.value, __WellOriginX.set, None, '\n            This defines the X position to use for the origin of the\n            fields (individual images) taken in a well. It is used\n            with the X in the WellSample to display the fields\n            in the correct position relative to each other. Each Well\n            in the plate has the same well origin. Units are set by WellOriginXUnit.\n\n            In the OMERO clients by convention we display the WellOrigin\n            in the center of the view.\n          ')

    
    # Attribute WellOriginXUnit uses Python identifier WellOriginXUnit
    __WellOriginXUnit = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'WellOriginXUnit'), 'WellOriginXUnit', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_54_WellOriginXUnit', _module_typeBindings.UnitsLength, unicode_default='reference frame')
    __WellOriginXUnit._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4396, 6)
    __WellOriginXUnit._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4396, 6)
    
    WellOriginXUnit = property(__WellOriginXUnit.value, __WellOriginXUnit.set, None, 'The units of the well origin in X - default:reference frame.')

    
    # Attribute WellOriginY uses Python identifier WellOriginY
    __WellOriginY = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'WellOriginY'), 'WellOriginY', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_54_WellOriginY', pyxb.binding.datatypes.float)
    __WellOriginY._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4401, 6)
    __WellOriginY._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4401, 6)
    
    WellOriginY = property(__WellOriginY.value, __WellOriginY.set, None, '\n            This defines the Y position to use for the origin of the\n            fields (individual images) taken in a well. It is used\n            with the Y in the WellSample to display the fields\n            in the correct position relative to each other. Each Well\n            in the plate has the same well origin.  Units are set by WellOriginYUnit.\n\n            In the OMERO clients by convention we display the WellOrigin\n            in the center of the view.\n          ')

    
    # Attribute WellOriginYUnit uses Python identifier WellOriginYUnit
    __WellOriginYUnit = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'WellOriginYUnit'), 'WellOriginYUnit', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_54_WellOriginYUnit', _module_typeBindings.UnitsLength, unicode_default='reference frame')
    __WellOriginYUnit._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4415, 6)
    __WellOriginYUnit._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4415, 6)
    
    WellOriginYUnit = property(__WellOriginYUnit.value, __WellOriginYUnit.set, None, 'The units of the well origin in Y - default:reference frame.')

    
    # Attribute Rows uses Python identifier Rows
    __Rows = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'Rows'), 'Rows', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_54_Rows', _module_typeBindings.PositiveInt)
    __Rows._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4420, 6)
    __Rows._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4420, 6)
    
    Rows = property(__Rows.value, __Rows.set, None, '\n            The number of rows in the plate\n          ')

    
    # Attribute Columns uses Python identifier Columns
    __Columns = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'Columns'), 'Columns', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_54_Columns', _module_typeBindings.PositiveInt)
    __Columns._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4427, 6)
    __Columns._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4427, 6)
    
    Columns = property(__Columns.value, __Columns.set, None, '\n            The number of columns in the plate\n          ')

    
    # Attribute FieldIndex uses Python identifier FieldIndex
    __FieldIndex = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'FieldIndex'), 'FieldIndex', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_54_FieldIndex', _module_typeBindings.NonNegativeInt)
    __FieldIndex._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4434, 6)
    __FieldIndex._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4434, 6)
    
    FieldIndex = property(__FieldIndex.value, __FieldIndex.set, None, '\n            The index of the WellSample to display as the default Field\n          ')

    _ElementMap.update({
        __AnnotationRef.name() : __AnnotationRef,
        __Description.name() : __Description,
        __PlateAcquisition.name() : __PlateAcquisition,
        __Well.name() : __Well
    })
    _AttributeMap.update({
        __ID.name() : __ID,
        __Name.name() : __Name,
        __Status.name() : __Status,
        __ExternalIdentifier.name() : __ExternalIdentifier,
        __ColumnNamingConvention.name() : __ColumnNamingConvention,
        __RowNamingConvention.name() : __RowNamingConvention,
        __WellOriginX.name() : __WellOriginX,
        __WellOriginXUnit.name() : __WellOriginXUnit,
        __WellOriginY.name() : __WellOriginY,
        __WellOriginYUnit.name() : __WellOriginYUnit,
        __Rows.name() : __Rows,
        __Columns.name() : __Columns,
        __FieldIndex.name() : __FieldIndex
    })
_module_typeBindings.CTD_ANON_54 = CTD_ANON_54


# Complex type [anonymous] with content type ELEMENT_ONLY
class CTD_ANON_55 (pyxb.binding.basis.complexTypeDefinition):
    """
        Reagent is used to describe a chemical or some other physical experimental parameter.
      """
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = None
    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4505, 4)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}AnnotationRef uses Python identifier AnnotationRef
    __AnnotationRef = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'AnnotationRef'), 'AnnotationRef', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_55_httpwww_openmicroscopy_orgSchemasOME2016_06AnnotationRef', True, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3435, 2), )

    
    AnnotationRef = property(__AnnotationRef.value, __AnnotationRef.set, None, '\n        The AnnotationRef element is a reference to an element derived\n        from the CommonAnnotation element.\n      ')

    
    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}Description uses Python identifier Description
    __Description = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'Description'), 'Description', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_55_httpwww_openmicroscopy_orgSchemasOME2016_06Description', False, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4507, 8), )

    
    Description = property(__Description.value, __Description.set, None, '\n              A long description for the reagent.\n            ')

    
    # Attribute ID uses Python identifier ID
    __ID = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'ID'), 'ID', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_55_ID', _module_typeBindings.ReagentID, required=True)
    __ID._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4525, 6)
    __ID._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4525, 6)
    
    ID = property(__ID.value, __ID.set, None, None)

    
    # Attribute Name uses Python identifier Name
    __Name = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'Name'), 'Name', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_55_Name', pyxb.binding.datatypes.string)
    __Name._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4526, 6)
    __Name._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4526, 6)
    
    Name = property(__Name.value, __Name.set, None, '\n            A short name for the reagent\n          ')

    
    # Attribute ReagentIdentifier uses Python identifier ReagentIdentifier
    __ReagentIdentifier = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'ReagentIdentifier'), 'ReagentIdentifier', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_55_ReagentIdentifier', pyxb.binding.datatypes.string)
    __ReagentIdentifier._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4533, 6)
    __ReagentIdentifier._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4533, 6)
    
    ReagentIdentifier = property(__ReagentIdentifier.value, __ReagentIdentifier.set, None, '\n            This is a reference to an external (to OME) representation of the Reagent.\n            It serves as a foreign key into an external database. - It is sometimes referred to as ExternalIdentifier.\n          ')

    _ElementMap.update({
        __AnnotationRef.name() : __AnnotationRef,
        __Description.name() : __Description
    })
    _AttributeMap.update({
        __ID.name() : __ID,
        __Name.name() : __Name,
        __ReagentIdentifier.name() : __ReagentIdentifier
    })
_module_typeBindings.CTD_ANON_55 = CTD_ANON_55


# Complex type [anonymous] with content type EMPTY
class CTD_ANON_56 (Reference):
    """Complex type [anonymous] with content type EMPTY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_EMPTY
    _Abstract = False
    _ExpandedName = None
    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4545, 4)
    _ElementMap = Reference._ElementMap.copy()
    _AttributeMap = Reference._AttributeMap.copy()
    # Base type is Reference
    
    # Attribute ID uses Python identifier ID
    __ID = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'ID'), 'ID', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_56_ID', _module_typeBindings.ReagentID, required=True)
    __ID._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4548, 10)
    __ID._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4548, 10)
    
    ID = property(__ID.value, __ID.set, None, None)

    _ElementMap.update({
        
    })
    _AttributeMap.update({
        __ID.name() : __ID
    })
_module_typeBindings.CTD_ANON_56 = CTD_ANON_56


# Complex type [anonymous] with content type ELEMENT_ONLY
class CTD_ANON_57 (pyxb.binding.basis.complexTypeDefinition):
    """
        The Screen element is a grouping for Plates.
        The required attribute is the Screen's Name and ID - both must be unique within the document.
        The Screen element may contain an ExternalRef attribute that refers to an external database.
        A description of the screen may be specified in the Description element.
        Screens may contain overlapping sets of Plates i.e.      Screens and Plates have a many-to-many relationship.
        Plates contain one or more ScreenRef elements to specify what screens they belong to.
      """
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = None
    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4572, 4)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}AnnotationRef uses Python identifier AnnotationRef
    __AnnotationRef = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'AnnotationRef'), 'AnnotationRef', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_57_httpwww_openmicroscopy_orgSchemasOME2016_06AnnotationRef', True, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3435, 2), )

    
    AnnotationRef = property(__AnnotationRef.value, __AnnotationRef.set, None, '\n        The AnnotationRef element is a reference to an element derived\n        from the CommonAnnotation element.\n      ')

    
    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}Reagent uses Python identifier Reagent
    __Reagent = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'Reagent'), 'Reagent', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_57_httpwww_openmicroscopy_orgSchemasOME2016_06Reagent', True, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4498, 2), )

    
    Reagent = property(__Reagent.value, __Reagent.set, None, '\n        Reagent is used to describe a chemical or some other physical experimental parameter.\n      ')

    
    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}Description uses Python identifier Description
    __Description = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'Description'), 'Description', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_57_httpwww_openmicroscopy_orgSchemasOME2016_06Description', False, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4574, 8), )

    
    Description = property(__Description.value, __Description.set, None, '\n              A description for the screen.\n            ')

    
    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}PlateRef uses Python identifier PlateRef
    __PlateRef = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'PlateRef'), 'PlateRef', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_57_httpwww_openmicroscopy_orgSchemasOME2016_06PlateRef', True, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4587, 8), )

    
    PlateRef = property(__PlateRef.value, __PlateRef.set, None, '\n              The PlateRef element is a reference to a Plate element.\n              Screen elements may have one or more PlateRef elements to define the plates that are part of the screen.\n              Plates may belong to more than one screen.\n            ')

    
    # Attribute ID uses Python identifier ID
    __ID = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'ID'), 'ID', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_57_ID', _module_typeBindings.ScreenID, required=True)
    __ID._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4610, 6)
    __ID._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4610, 6)
    
    ID = property(__ID.value, __ID.set, None, None)

    
    # Attribute Name uses Python identifier Name
    __Name = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'Name'), 'Name', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_57_Name', pyxb.binding.datatypes.string)
    __Name._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4611, 6)
    __Name._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4611, 6)
    
    Name = property(__Name.value, __Name.set, None, None)

    
    # Attribute ProtocolIdentifier uses Python identifier ProtocolIdentifier
    __ProtocolIdentifier = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'ProtocolIdentifier'), 'ProtocolIdentifier', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_57_ProtocolIdentifier', pyxb.binding.datatypes.string)
    __ProtocolIdentifier._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4612, 6)
    __ProtocolIdentifier._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4612, 6)
    
    ProtocolIdentifier = property(__ProtocolIdentifier.value, __ProtocolIdentifier.set, None, '\n            A pointer to an externally defined protocol, usually in a screening database.\n          ')

    
    # Attribute ProtocolDescription uses Python identifier ProtocolDescription
    __ProtocolDescription = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'ProtocolDescription'), 'ProtocolDescription', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_57_ProtocolDescription', pyxb.binding.datatypes.string)
    __ProtocolDescription._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4619, 6)
    __ProtocolDescription._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4619, 6)
    
    ProtocolDescription = property(__ProtocolDescription.value, __ProtocolDescription.set, None, '\n            A description of the screen protocol; may contain very detailed information to\n            reproduce some of that found in a screening database.\n          ')

    
    # Attribute ReagentSetDescription uses Python identifier ReagentSetDescription
    __ReagentSetDescription = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'ReagentSetDescription'), 'ReagentSetDescription', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_57_ReagentSetDescription', pyxb.binding.datatypes.string)
    __ReagentSetDescription._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4627, 6)
    __ReagentSetDescription._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4627, 6)
    
    ReagentSetDescription = property(__ReagentSetDescription.value, __ReagentSetDescription.set, None, '\n            A description of the set of reagents; may contain very detailed information to\n            reproduce some of that information found in a screening database.\n          ')

    
    # Attribute ReagentSetIdentifier uses Python identifier ReagentSetIdentifier
    __ReagentSetIdentifier = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'ReagentSetIdentifier'), 'ReagentSetIdentifier', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_57_ReagentSetIdentifier', pyxb.binding.datatypes.string)
    __ReagentSetIdentifier._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4635, 6)
    __ReagentSetIdentifier._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4635, 6)
    
    ReagentSetIdentifier = property(__ReagentSetIdentifier.value, __ReagentSetIdentifier.set, None, '\n            A pointer to an externally defined set of reagents, usually in a screening\n            database/automation database.\n          ')

    
    # Attribute Type uses Python identifier Type
    __Type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'Type'), 'Type', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_57_Type', pyxb.binding.datatypes.string)
    __Type._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4643, 6)
    __Type._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4643, 6)
    
    Type = property(__Type.value, __Type.set, None, '\n            A human readable identifier for the screen type; e.g. RNAi, cDNA, SiRNA, etc.\n            This string is likely to become an enumeration in future releases.\n          ')

    _ElementMap.update({
        __AnnotationRef.name() : __AnnotationRef,
        __Reagent.name() : __Reagent,
        __Description.name() : __Description,
        __PlateRef.name() : __PlateRef
    })
    _AttributeMap.update({
        __ID.name() : __ID,
        __Name.name() : __Name,
        __ProtocolIdentifier.name() : __ProtocolIdentifier,
        __ProtocolDescription.name() : __ProtocolDescription,
        __ReagentSetDescription.name() : __ReagentSetDescription,
        __ReagentSetIdentifier.name() : __ReagentSetIdentifier,
        __Type.name() : __Type
    })
_module_typeBindings.CTD_ANON_57 = CTD_ANON_57


# Complex type [anonymous] with content type EMPTY
class CTD_ANON_58 (Reference):
    """
              The PlateRef element is a reference to a Plate element.
              Screen elements may have one or more PlateRef elements to define the plates that are part of the screen.
              Plates may belong to more than one screen.
            """
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_EMPTY
    _Abstract = False
    _ExpandedName = None
    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4596, 10)
    _ElementMap = Reference._ElementMap.copy()
    _AttributeMap = Reference._AttributeMap.copy()
    # Base type is Reference
    
    # Attribute ID uses Python identifier ID
    __ID = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'ID'), 'ID', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_58_ID', _module_typeBindings.PlateID, required=True)
    __ID._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4599, 16)
    __ID._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4599, 16)
    
    ID = property(__ID.value, __ID.set, None, None)

    _ElementMap.update({
        
    })
    _AttributeMap.update({
        __ID.name() : __ID
    })
_module_typeBindings.CTD_ANON_58 = CTD_ANON_58


# Complex type [anonymous] with content type ELEMENT_ONLY
class CTD_ANON_59 (pyxb.binding.basis.complexTypeDefinition):
    """
        PlateAcquisition is used to describe a single acquisition run for a plate.
        This object is used to record the set of images acquired in a single
        acquisition run. The Images for this run are linked to PlateAcquisition
        through WellSample.
      """
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = None
    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4670, 4)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}AnnotationRef uses Python identifier AnnotationRef
    __AnnotationRef = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'AnnotationRef'), 'AnnotationRef', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_59_httpwww_openmicroscopy_orgSchemasOME2016_06AnnotationRef', True, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3435, 2), )

    
    AnnotationRef = property(__AnnotationRef.value, __AnnotationRef.set, None, '\n        The AnnotationRef element is a reference to an element derived\n        from the CommonAnnotation element.\n      ')

    
    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}Description uses Python identifier Description
    __Description = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'Description'), 'Description', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_59_httpwww_openmicroscopy_orgSchemasOME2016_06Description', False, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4672, 8), )

    
    Description = property(__Description.value, __Description.set, None, '\n              A description for the PlateAcquisition.\n            ')

    
    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}WellSampleRef uses Python identifier WellSampleRef
    __WellSampleRef = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'WellSampleRef'), 'WellSampleRef', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_59_httpwww_openmicroscopy_orgSchemasOME2016_06WellSampleRef', True, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4883, 2), )

    
    WellSampleRef = property(__WellSampleRef.value, __WellSampleRef.set, None, '\n        The WellSampleRef element is a reference to a WellSample element.\n      ')

    
    # Attribute ID uses Python identifier ID
    __ID = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'ID'), 'ID', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_59_ID', _module_typeBindings.PlateAcquisitionID, required=True)
    __ID._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4691, 6)
    __ID._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4691, 6)
    
    ID = property(__ID.value, __ID.set, None, None)

    
    # Attribute Name uses Python identifier Name
    __Name = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'Name'), 'Name', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_59_Name', pyxb.binding.datatypes.string)
    __Name._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4692, 6)
    __Name._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4692, 6)
    
    Name = property(__Name.value, __Name.set, None, None)

    
    # Attribute EndTime uses Python identifier EndTime
    __EndTime = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'EndTime'), 'EndTime', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_59_EndTime', pyxb.binding.datatypes.dateTime)
    __EndTime._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4693, 6)
    __EndTime._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4693, 6)
    
    EndTime = property(__EndTime.value, __EndTime.set, None, '\n            Time when the last image of this acquisition was collected\n          ')

    
    # Attribute StartTime uses Python identifier StartTime
    __StartTime = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'StartTime'), 'StartTime', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_59_StartTime', pyxb.binding.datatypes.dateTime)
    __StartTime._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4700, 6)
    __StartTime._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4700, 6)
    
    StartTime = property(__StartTime.value, __StartTime.set, None, '\n            Time when the first image of this acquisition was collected\n          ')

    
    # Attribute MaximumFieldCount uses Python identifier MaximumFieldCount
    __MaximumFieldCount = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'MaximumFieldCount'), 'MaximumFieldCount', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_59_MaximumFieldCount', _module_typeBindings.PositiveInt)
    __MaximumFieldCount._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4707, 6)
    __MaximumFieldCount._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4707, 6)
    
    MaximumFieldCount = property(__MaximumFieldCount.value, __MaximumFieldCount.set, None, '\n            The maximum number of fields (well samples) in any well\n            in this PlateAcquisition.\n            This is only used to speed up user interaction by stopping\n            the reading of every well sample.\n          ')

    _ElementMap.update({
        __AnnotationRef.name() : __AnnotationRef,
        __Description.name() : __Description,
        __WellSampleRef.name() : __WellSampleRef
    })
    _AttributeMap.update({
        __ID.name() : __ID,
        __Name.name() : __Name,
        __EndTime.name() : __EndTime,
        __StartTime.name() : __StartTime,
        __MaximumFieldCount.name() : __MaximumFieldCount
    })
_module_typeBindings.CTD_ANON_59 = CTD_ANON_59


# Complex type [anonymous] with content type ELEMENT_ONLY
class CTD_ANON_60 (pyxb.binding.basis.complexTypeDefinition):
    """
        A Well is a component of the Well/Plate/Screen construct to describe screening applications.
        A Well has a number of WellSample elements that link to the Images collected in this well.
        The ReagentRef links any Reagents that were used in this Well. A well is part of only one Plate.
        The origin for the row and column identifiers is the top left corner of the plate starting at zero.
        i.e The top left well of a plate is index (0,0)
      """
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = None
    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4737, 4)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}AnnotationRef uses Python identifier AnnotationRef
    __AnnotationRef = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'AnnotationRef'), 'AnnotationRef', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_60_httpwww_openmicroscopy_orgSchemasOME2016_06AnnotationRef', True, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3435, 2), )

    
    AnnotationRef = property(__AnnotationRef.value, __AnnotationRef.set, None, '\n        The AnnotationRef element is a reference to an element derived\n        from the CommonAnnotation element.\n      ')

    
    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}ReagentRef uses Python identifier ReagentRef
    __ReagentRef = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'ReagentRef'), 'ReagentRef', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_60_httpwww_openmicroscopy_orgSchemasOME2016_06ReagentRef', False, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4544, 2), )

    
    ReagentRef = property(__ReagentRef.value, __ReagentRef.set, None, None)

    
    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}WellSample uses Python identifier WellSample
    __WellSample = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'WellSample'), 'WellSample', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_60_httpwww_openmicroscopy_orgSchemasOME2016_06WellSample', True, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4810, 2), )

    
    WellSample = property(__WellSample.value, __WellSample.set, None, '\n        WellSample is an individual image that has been captured within a Well.\n      ')

    
    # Attribute ID uses Python identifier ID
    __ID = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'ID'), 'ID', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_60_ID', _module_typeBindings.WellID, required=True)
    __ID._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4751, 6)
    __ID._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4751, 6)
    
    ID = property(__ID.value, __ID.set, None, None)

    
    # Attribute Column uses Python identifier Column
    __Column = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'Column'), 'Column', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_60_Column', _module_typeBindings.NonNegativeInt, required=True)
    __Column._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4752, 6)
    __Column._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4752, 6)
    
    Column = property(__Column.value, __Column.set, None, '\n            This is the column index of the well, the origin is the top left corner of the plate\n            with the first column of cells being column zero. i.e top left is (0,0)\n            The combination of Row, Column has to be unique for each well in a plate.\n          ')

    
    # Attribute Row uses Python identifier Row
    __Row = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'Row'), 'Row', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_60_Row', _module_typeBindings.NonNegativeInt, required=True)
    __Row._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4761, 6)
    __Row._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4761, 6)
    
    Row = property(__Row.value, __Row.set, None, '\n            This is the row index of the well, the origin is the top left corner of the plate\n            with the first row of wells being row zero. i.e top left is (0,0)\n            The combination of Row, Column has to be unique for each well in a plate.\n          ')

    
    # Attribute ExternalDescription uses Python identifier ExternalDescription
    __ExternalDescription = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'ExternalDescription'), 'ExternalDescription', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_60_ExternalDescription', pyxb.binding.datatypes.string)
    __ExternalDescription._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4770, 6)
    __ExternalDescription._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4770, 6)
    
    ExternalDescription = property(__ExternalDescription.value, __ExternalDescription.set, None, '\n            A description of the externally defined identifier for this plate.\n          ')

    
    # Attribute ExternalIdentifier uses Python identifier ExternalIdentifier
    __ExternalIdentifier = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'ExternalIdentifier'), 'ExternalIdentifier', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_60_ExternalIdentifier', pyxb.binding.datatypes.string)
    __ExternalIdentifier._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4777, 6)
    __ExternalIdentifier._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4777, 6)
    
    ExternalIdentifier = property(__ExternalIdentifier.value, __ExternalIdentifier.set, None, '\n            The ExternalIdentifier attribute may contain a reference to an external database.\n          ')

    
    # Attribute Type uses Python identifier Type
    __Type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'Type'), 'Type', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_60_Type', pyxb.binding.datatypes.string)
    __Type._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4784, 6)
    __Type._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4784, 6)
    
    Type = property(__Type.value, __Type.set, None, '\n            A human readable identifier for the screening status.\n            e.g. empty, positive control, negative control, control, experimental, etc.\n          ')

    
    # Attribute Color uses Python identifier Color
    __Color = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'Color'), 'Color', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_60_Color', _module_typeBindings.Color, unicode_default='-1')
    __Color._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4792, 6)
    __Color._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4792, 6)
    
    Color = property(__Color.value, __Color.set, None, '\n            A marker color used to highlight the well - encoded as RGBA\n            The default value "-1" is #FFFFFFFF so solid white (it is a signed 32 bit value)\n            NOTE: Prior to the 2012-06 schema the default value was incorrect and produced a transparent red not solid white.\n          ')

    _ElementMap.update({
        __AnnotationRef.name() : __AnnotationRef,
        __ReagentRef.name() : __ReagentRef,
        __WellSample.name() : __WellSample
    })
    _AttributeMap.update({
        __ID.name() : __ID,
        __Column.name() : __Column,
        __Row.name() : __Row,
        __ExternalDescription.name() : __ExternalDescription,
        __ExternalIdentifier.name() : __ExternalIdentifier,
        __Type.name() : __Type,
        __Color.name() : __Color
    })
_module_typeBindings.CTD_ANON_60 = CTD_ANON_60


# Complex type [anonymous] with content type ELEMENT_ONLY
class CTD_ANON_61 (pyxb.binding.basis.complexTypeDefinition):
    """
        WellSample is an individual image that has been captured within a Well.
      """
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = None
    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4817, 4)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}ImageRef uses Python identifier ImageRef
    __ImageRef = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'ImageRef'), 'ImageRef', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_61_httpwww_openmicroscopy_orgSchemasOME2016_06ImageRef', False, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2844, 2), )

    
    ImageRef = property(__ImageRef.value, __ImageRef.set, None, '\n        The ImageRef element is a reference to an Image element.\n      ')

    
    # Attribute ID uses Python identifier ID
    __ID = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'ID'), 'ID', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_61_ID', _module_typeBindings.WellSampleID, required=True)
    __ID._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4828, 6)
    __ID._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4828, 6)
    
    ID = property(__ID.value, __ID.set, None, None)

    
    # Attribute PositionX uses Python identifier PositionX
    __PositionX = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'PositionX'), 'PositionX', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_61_PositionX', pyxb.binding.datatypes.float)
    __PositionX._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4829, 6)
    __PositionX._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4829, 6)
    
    PositionX = property(__PositionX.value, __PositionX.set, None, '\n            The X position of the field (image) within the well relative to\n            the well origin defined on the Plate. Units are set by PositionXUnit.\n          ')

    
    # Attribute PositionXUnit uses Python identifier PositionXUnit
    __PositionXUnit = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'PositionXUnit'), 'PositionXUnit', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_61_PositionXUnit', _module_typeBindings.UnitsLength, unicode_default='reference frame')
    __PositionXUnit._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4837, 6)
    __PositionXUnit._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4837, 6)
    
    PositionXUnit = property(__PositionXUnit.value, __PositionXUnit.set, None, 'The units of the position in X - default:reference frame.')

    
    # Attribute PositionY uses Python identifier PositionY
    __PositionY = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'PositionY'), 'PositionY', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_61_PositionY', pyxb.binding.datatypes.float)
    __PositionY._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4842, 6)
    __PositionY._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4842, 6)
    
    PositionY = property(__PositionY.value, __PositionY.set, None, '\n            The Y position of the field (image) within the well relative to\n            the well origin defined on the Plate. Units are set by PositionYUnit.\n          ')

    
    # Attribute PositionYUnit uses Python identifier PositionYUnit
    __PositionYUnit = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'PositionYUnit'), 'PositionYUnit', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_61_PositionYUnit', _module_typeBindings.UnitsLength, unicode_default='reference frame')
    __PositionYUnit._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4850, 6)
    __PositionYUnit._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4850, 6)
    
    PositionYUnit = property(__PositionYUnit.value, __PositionYUnit.set, None, 'The units of the position in Y - default:reference frame.')

    
    # Attribute Timepoint uses Python identifier Timepoint
    __Timepoint = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'Timepoint'), 'Timepoint', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_61_Timepoint', pyxb.binding.datatypes.dateTime)
    __Timepoint._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4855, 6)
    __Timepoint._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4855, 6)
    
    Timepoint = property(__Timepoint.value, __Timepoint.set, None, '\n            The time-point at which the image started to be collected\n          ')

    
    # Attribute Index uses Python identifier Index
    __Index = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'Index'), 'Index', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_61_Index', _module_typeBindings.NonNegativeInt, required=True)
    __Index._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4862, 6)
    __Index._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4862, 6)
    
    Index = property(__Index.value, __Index.set, None, '\n            This records the order of the well samples. Each\n            index should be unique for a given plate but they do not\n            have to be sequential, there may be gaps if part of the\n            dataset is missing. In the user interface the displayed\n            value of the index will be calculated modulo the number\n            of PlateAcquisitions for the plate.\n          ')

    _ElementMap.update({
        __ImageRef.name() : __ImageRef
    })
    _AttributeMap.update({
        __ID.name() : __ID,
        __PositionX.name() : __PositionX,
        __PositionXUnit.name() : __PositionXUnit,
        __PositionY.name() : __PositionY,
        __PositionYUnit.name() : __PositionYUnit,
        __Timepoint.name() : __Timepoint,
        __Index.name() : __Index
    })
_module_typeBindings.CTD_ANON_61 = CTD_ANON_61


# Complex type [anonymous] with content type EMPTY
class CTD_ANON_62 (Reference):
    """
        The WellSampleRef element is a reference to a WellSample element.
      """
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_EMPTY
    _Abstract = False
    _ExpandedName = None
    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4889, 4)
    _ElementMap = Reference._ElementMap.copy()
    _AttributeMap = Reference._AttributeMap.copy()
    # Base type is Reference
    
    # Attribute ID uses Python identifier ID
    __ID = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'ID'), 'ID', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_62_ID', _module_typeBindings.WellSampleID, required=True)
    __ID._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4892, 10)
    __ID._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4892, 10)
    
    ID = property(__ID.value, __ID.set, None, None)

    _ElementMap.update({
        
    })
    _AttributeMap.update({
        __ID.name() : __ID
    })
_module_typeBindings.CTD_ANON_62 = CTD_ANON_62


# Complex type [anonymous] with content type ELEMENT_ONLY
class CTD_ANON_63 (LightSource):
    """
        Laser types are specified using two attributes - the Type and the LaserMedium.
      """
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = None
    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2504, 4)
    _ElementMap = LightSource._ElementMap.copy()
    _AttributeMap = LightSource._AttributeMap.copy()
    # Base type is LightSource
    
    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}Pump uses Python identifier Pump
    __Pump = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'Pump'), 'Pump', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_63_httpwww_openmicroscopy_orgSchemasOME2016_06Pump', False, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2778, 2), )

    
    Pump = property(__Pump.value, __Pump.set, None, "\n        The Pump element is a reference to a LightSource.  It is used within the Laser element to specify the light source for the laser's pump (if any).\n      ")

    
    # Element AnnotationRef ({http://www.openmicroscopy.org/Schemas/OME/2016-06}AnnotationRef) inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}LightSource
    
    # Attribute Manufacturer inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}ManufacturerSpec
    
    # Attribute Model inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}ManufacturerSpec
    
    # Attribute SerialNumber inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}ManufacturerSpec
    
    # Attribute LotNumber inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}ManufacturerSpec
    
    # Attribute ID inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}LightSource
    
    # Attribute Power inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}LightSource
    
    # Attribute PowerUnit inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}LightSource
    
    # Attribute Type uses Python identifier Type
    __Type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'Type'), 'Type', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_63_Type', _module_typeBindings.STD_ANON_18)
    __Type._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2517, 10)
    __Type._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2517, 10)
    
    Type = property(__Type.value, __Type.set, None, '\n                Type is the general category of laser.\n              ')

    
    # Attribute LaserMedium uses Python identifier LaserMedium
    __LaserMedium = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'LaserMedium'), 'LaserMedium', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_63_LaserMedium', _module_typeBindings.STD_ANON_19)
    __LaserMedium._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2536, 10)
    __LaserMedium._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2536, 10)
    
    LaserMedium = property(__LaserMedium.value, __LaserMedium.set, None, '\n                The Medium attribute specifies the actual lasing medium\n                for a given laser type.\n              ')

    
    # Attribute Wavelength uses Python identifier Wavelength
    __Wavelength = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'Wavelength'), 'Wavelength', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_63_Wavelength', _module_typeBindings.PositiveFloat)
    __Wavelength._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2590, 10)
    __Wavelength._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2590, 10)
    
    Wavelength = property(__Wavelength.value, __Wavelength.set, None, '\n                The Wavelength of the laser. Units are set by WavelengthUnit.\n              ')

    
    # Attribute WavelengthUnit uses Python identifier WavelengthUnit
    __WavelengthUnit = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'WavelengthUnit'), 'WavelengthUnit', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_63_WavelengthUnit', _module_typeBindings.UnitsLength, unicode_default='nm')
    __WavelengthUnit._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2597, 10)
    __WavelengthUnit._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2597, 10)
    
    WavelengthUnit = property(__WavelengthUnit.value, __WavelengthUnit.set, None, 'The units of the Wavelength - default:nanometres[nm].')

    
    # Attribute FrequencyMultiplication uses Python identifier FrequencyMultiplication
    __FrequencyMultiplication = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'FrequencyMultiplication'), 'FrequencyMultiplication', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_63_FrequencyMultiplication', _module_typeBindings.PositiveInt)
    __FrequencyMultiplication._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2602, 10)
    __FrequencyMultiplication._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2602, 10)
    
    FrequencyMultiplication = property(__FrequencyMultiplication.value, __FrequencyMultiplication.set, None, '\n                FrequencyMultiplication that may be specified. [units:none]\n              ')

    
    # Attribute Tuneable uses Python identifier Tuneable
    __Tuneable = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'Tuneable'), 'Tuneable', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_63_Tuneable', pyxb.binding.datatypes.boolean)
    __Tuneable._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2609, 10)
    __Tuneable._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2609, 10)
    
    Tuneable = property(__Tuneable.value, __Tuneable.set, None, '\n                Whether or not the laser is Tuneable [flag]\n              ')

    
    # Attribute Pulse uses Python identifier Pulse
    __Pulse = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'Pulse'), 'Pulse', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_63_Pulse', _module_typeBindings.STD_ANON_20)
    __Pulse._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2616, 10)
    __Pulse._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2616, 10)
    
    Pulse = property(__Pulse.value, __Pulse.set, None, '\n                The Pulse mode of the laser.\n              ')

    
    # Attribute PockelCell uses Python identifier PockelCell
    __PockelCell = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'PockelCell'), 'PockelCell', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_63_PockelCell', pyxb.binding.datatypes.boolean)
    __PockelCell._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2633, 10)
    __PockelCell._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2633, 10)
    
    PockelCell = property(__PockelCell.value, __PockelCell.set, None, '\n                If true the laser has a PockelCell to rotate the polarization of the beam. [flag]\n              ')

    
    # Attribute RepetitionRate uses Python identifier RepetitionRate
    __RepetitionRate = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'RepetitionRate'), 'RepetitionRate', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_63_RepetitionRate', pyxb.binding.datatypes.float)
    __RepetitionRate._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2640, 10)
    __RepetitionRate._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2640, 10)
    
    RepetitionRate = property(__RepetitionRate.value, __RepetitionRate.set, None, "\n                The is the rate in Hz at which the laser pulses if\n                the Pulse type is 'Repetitive'. hertz[Hz]\n                Units are set by RepetitionRateUnit.\n              ")

    
    # Attribute RepetitionRateUnit uses Python identifier RepetitionRateUnit
    __RepetitionRateUnit = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'RepetitionRateUnit'), 'RepetitionRateUnit', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_63_RepetitionRateUnit', _module_typeBindings.UnitsFrequency, unicode_default='Hz')
    __RepetitionRateUnit._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2649, 10)
    __RepetitionRateUnit._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2649, 10)
    
    RepetitionRateUnit = property(__RepetitionRateUnit.value, __RepetitionRateUnit.set, None, 'The units of the RepetitionRate - default:hertz[Hz].')

    _ElementMap.update({
        __Pump.name() : __Pump
    })
    _AttributeMap.update({
        __Type.name() : __Type,
        __LaserMedium.name() : __LaserMedium,
        __Wavelength.name() : __Wavelength,
        __WavelengthUnit.name() : __WavelengthUnit,
        __FrequencyMultiplication.name() : __FrequencyMultiplication,
        __Tuneable.name() : __Tuneable,
        __Pulse.name() : __Pulse,
        __PockelCell.name() : __PockelCell,
        __RepetitionRate.name() : __RepetitionRate,
        __RepetitionRateUnit.name() : __RepetitionRateUnit
    })
_module_typeBindings.CTD_ANON_63 = CTD_ANON_63


# Complex type [anonymous] with content type ELEMENT_ONLY
class CTD_ANON_64 (LightSource):
    """
        The Arc element is used to describe various kinds of Arc lamps - Hg, Xe, HgXe.
        The Power of the Arc is now stored in the LightSource.
      """
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = None
    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2666, 4)
    _ElementMap = LightSource._ElementMap.copy()
    _AttributeMap = LightSource._AttributeMap.copy()
    # Base type is LightSource
    
    # Element AnnotationRef ({http://www.openmicroscopy.org/Schemas/OME/2016-06}AnnotationRef) inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}LightSource
    
    # Attribute Manufacturer inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}ManufacturerSpec
    
    # Attribute Model inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}ManufacturerSpec
    
    # Attribute SerialNumber inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}ManufacturerSpec
    
    # Attribute LotNumber inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}ManufacturerSpec
    
    # Attribute ID inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}LightSource
    
    # Attribute Power inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}LightSource
    
    # Attribute PowerUnit inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}LightSource
    
    # Attribute Type uses Python identifier Type
    __Type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'Type'), 'Type', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_64_Type', _module_typeBindings.STD_ANON_21)
    __Type._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2669, 10)
    __Type._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2669, 10)
    
    Type = property(__Type.value, __Type.set, None, '\n                The type of Arc lamp.\n              ')

    _ElementMap.update({
        
    })
    _AttributeMap.update({
        __Type.name() : __Type
    })
_module_typeBindings.CTD_ANON_64 = CTD_ANON_64


# Complex type [anonymous] with content type ELEMENT_ONLY
class CTD_ANON_65 (LightSource):
    """
        The Filament element is used to describe various kinds of filament bulbs such as Incadescent or Halogen.
        The Power of the Filament is now stored in the LightSource.
      """
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = None
    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2696, 4)
    _ElementMap = LightSource._ElementMap.copy()
    _AttributeMap = LightSource._AttributeMap.copy()
    # Base type is LightSource
    
    # Element AnnotationRef ({http://www.openmicroscopy.org/Schemas/OME/2016-06}AnnotationRef) inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}LightSource
    
    # Attribute Manufacturer inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}ManufacturerSpec
    
    # Attribute Model inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}ManufacturerSpec
    
    # Attribute SerialNumber inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}ManufacturerSpec
    
    # Attribute LotNumber inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}ManufacturerSpec
    
    # Attribute ID inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}LightSource
    
    # Attribute Power inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}LightSource
    
    # Attribute PowerUnit inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}LightSource
    
    # Attribute Type uses Python identifier Type
    __Type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'Type'), 'Type', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_65_Type', _module_typeBindings.STD_ANON_22)
    __Type._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2699, 10)
    __Type._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2699, 10)
    
    Type = property(__Type.value, __Type.set, None, '\n                The type of filament.\n              ')

    _ElementMap.update({
        
    })
    _AttributeMap.update({
        __Type.name() : __Type
    })
_module_typeBindings.CTD_ANON_65 = CTD_ANON_65


# Complex type [anonymous] with content type ELEMENT_ONLY
class CTD_ANON_66 (LightSource):
    """
        The LightEmittingDiode element is used to describe
        various kinds of LED lamps.

        As the LightEmittingDiode is inside a LightSource it already has
        available the values from ManufacturerSpec
        (Manufacturer, Model, SerialNumber, LotNumber)
        And the values from LightSource which includes Power in milliwatts

        We have looked at extending this element but have had a problem
        producing a generic solution.

        Possible attributes talked about adding include:
        Power in lumens - but this is complicated by multi-channel
        devices like CoolLED where each channel's power is different
        Wavelength Range - not a simple value so would require
        multiple attributes or a child element
        Angle of Projection - this would be further affected by the
        optics used for filtering the naked LED or that combine
        power from multiple devices

        These values are further affected if you over-drive the LED
        resulting in a more complex system

        Another issue is that LED's may not be used directly for
        illumination but as drivers for secondary emissions from doped
        fiber optics. This would require the fiber optics to be modeled.

        Thanks to Paul Goodwin of Applied Precision of information about
        this topic.
      """
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = None
    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2752, 4)
    _ElementMap = LightSource._ElementMap.copy()
    _AttributeMap = LightSource._AttributeMap.copy()
    # Base type is LightSource
    
    # Element AnnotationRef ({http://www.openmicroscopy.org/Schemas/OME/2016-06}AnnotationRef) inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}LightSource
    
    # Attribute Manufacturer inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}ManufacturerSpec
    
    # Attribute Model inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}ManufacturerSpec
    
    # Attribute SerialNumber inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}ManufacturerSpec
    
    # Attribute LotNumber inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}ManufacturerSpec
    
    # Attribute ID inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}LightSource
    
    # Attribute Power inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}LightSource
    
    # Attribute PowerUnit inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}LightSource
    _ElementMap.update({
        
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.CTD_ANON_66 = CTD_ANON_66


# Complex type [anonymous] with content type ELEMENT_ONLY
class CTD_ANON_67 (LightSource):
    """
        The GenericExcitationSource element is used to represent
        a source as a collection of key/value pairs, stored
        in a Map. The other lightsource objects should
        always be used in preference to this if possible.
      """
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = None
    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2768, 4)
    _ElementMap = LightSource._ElementMap.copy()
    _AttributeMap = LightSource._AttributeMap.copy()
    # Base type is LightSource
    
    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}Map uses Python identifier Map
    __Map = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'Map'), 'Map', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_67_httpwww_openmicroscopy_orgSchemasOME2016_06Map', False, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2772, 12), )

    
    Map = property(__Map.value, __Map.set, None, None)

    
    # Element AnnotationRef ({http://www.openmicroscopy.org/Schemas/OME/2016-06}AnnotationRef) inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}LightSource
    
    # Attribute Manufacturer inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}ManufacturerSpec
    
    # Attribute Model inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}ManufacturerSpec
    
    # Attribute SerialNumber inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}ManufacturerSpec
    
    # Attribute LotNumber inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}ManufacturerSpec
    
    # Attribute ID inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}LightSource
    
    # Attribute Power inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}LightSource
    
    # Attribute PowerUnit inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}LightSource
    _ElementMap.update({
        __Map.name() : __Map
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.CTD_ANON_67 = CTD_ANON_67


# Complex type {http://www.openmicroscopy.org/Schemas/OME/2016-06}BasicAnnotation with content type ELEMENT_ONLY
class BasicAnnotation (Annotation):
    """
        An abstract Basic Annotation from which some others are derived.
      """
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'BasicAnnotation')
    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3507, 2)
    _ElementMap = Annotation._ElementMap.copy()
    _AttributeMap = Annotation._AttributeMap.copy()
    # Base type is Annotation
    
    # Element AnnotationRef ({http://www.openmicroscopy.org/Schemas/OME/2016-06}AnnotationRef) inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Annotation
    
    # Element Description ({http://www.openmicroscopy.org/Schemas/OME/2016-06}Description) inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Annotation
    
    # Attribute ID inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Annotation
    
    # Attribute Namespace_ inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Annotation
    
    # Attribute Annotator inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Annotation
    _ElementMap.update({
        
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.BasicAnnotation = BasicAnnotation
Namespace.addCategoryObject('typeBinding', 'BasicAnnotation', BasicAnnotation)


# Complex type {http://www.openmicroscopy.org/Schemas/OME/2016-06}TextAnnotation with content type ELEMENT_ONLY
class TextAnnotation (Annotation):
    """
        An abstract Text Annotation from which some others are derived.
      """
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'TextAnnotation')
    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3529, 2)
    _ElementMap = Annotation._ElementMap.copy()
    _AttributeMap = Annotation._AttributeMap.copy()
    # Base type is Annotation
    
    # Element AnnotationRef ({http://www.openmicroscopy.org/Schemas/OME/2016-06}AnnotationRef) inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Annotation
    
    # Element Description ({http://www.openmicroscopy.org/Schemas/OME/2016-06}Description) inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Annotation
    
    # Attribute ID inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Annotation
    
    # Attribute Namespace_ inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Annotation
    
    # Attribute Annotator inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Annotation
    _ElementMap.update({
        
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.TextAnnotation = TextAnnotation
Namespace.addCategoryObject('typeBinding', 'TextAnnotation', TextAnnotation)


# Complex type {http://www.openmicroscopy.org/Schemas/OME/2016-06}TypeAnnotation with content type ELEMENT_ONLY
class TypeAnnotation (Annotation):
    """
        An abstract Type Annotation from which some others are derived.
      """
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'TypeAnnotation')
    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3540, 2)
    _ElementMap = Annotation._ElementMap.copy()
    _AttributeMap = Annotation._AttributeMap.copy()
    # Base type is Annotation
    
    # Element AnnotationRef ({http://www.openmicroscopy.org/Schemas/OME/2016-06}AnnotationRef) inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Annotation
    
    # Element Description ({http://www.openmicroscopy.org/Schemas/OME/2016-06}Description) inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Annotation
    
    # Attribute ID inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Annotation
    
    # Attribute Namespace_ inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Annotation
    
    # Attribute Annotator inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Annotation
    _ElementMap.update({
        
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.TypeAnnotation = TypeAnnotation
Namespace.addCategoryObject('typeBinding', 'TypeAnnotation', TypeAnnotation)


# Complex type [anonymous] with content type ELEMENT_ONLY
class CTD_ANON_68 (Annotation):
    """
        This annotation is a grouping object. It uses the sequence of
        annotation refs from the base Annotation to form the list.
      """
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = None
    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3602, 4)
    _ElementMap = Annotation._ElementMap.copy()
    _AttributeMap = Annotation._AttributeMap.copy()
    # Base type is Annotation
    
    # Element AnnotationRef ({http://www.openmicroscopy.org/Schemas/OME/2016-06}AnnotationRef) inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Annotation
    
    # Element Description ({http://www.openmicroscopy.org/Schemas/OME/2016-06}Description) inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Annotation
    
    # Attribute ID inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Annotation
    
    # Attribute Namespace_ inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Annotation
    
    # Attribute Annotator inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Annotation
    _ElementMap.update({
        
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.CTD_ANON_68 = CTD_ANON_68


# Complex type [anonymous] with content type ELEMENT_ONLY
class CTD_ANON_69 (Annotation):
    """
        An map annotation. The contents of this is a list of key/value pairs.
      """
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = None
    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3734, 4)
    _ElementMap = Annotation._ElementMap.copy()
    _AttributeMap = Annotation._AttributeMap.copy()
    # Base type is Annotation
    
    # Element AnnotationRef ({http://www.openmicroscopy.org/Schemas/OME/2016-06}AnnotationRef) inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Annotation
    
    # Element Description ({http://www.openmicroscopy.org/Schemas/OME/2016-06}Description) inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Annotation
    
    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}Value uses Python identifier Value
    __Value = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'Value'), 'Value', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_69_httpwww_openmicroscopy_orgSchemasOME2016_06Value', False, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3738, 12), )

    
    Value = property(__Value.value, __Value.set, None, None)

    
    # Attribute ID inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Annotation
    
    # Attribute Namespace_ inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Annotation
    
    # Attribute Annotator inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Annotation
    _ElementMap.update({
        __Value.name() : __Value
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.CTD_ANON_69 = CTD_ANON_69


# Complex type [anonymous] with content type ELEMENT_ONLY
class CTD_ANON_70 (Shape):
    """
        A simple rectangle object. If rotation is required apply a
        transformation at the Shape level.
      """
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = None
    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3973, 4)
    _ElementMap = Shape._ElementMap.copy()
    _AttributeMap = Shape._AttributeMap.copy()
    # Base type is Shape
    
    # Element AnnotationRef ({http://www.openmicroscopy.org/Schemas/OME/2016-06}AnnotationRef) inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
    
    # Element Transform ({http://www.openmicroscopy.org/Schemas/OME/2016-06}Transform) inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
    
    # Attribute FillColor inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
    
    # Attribute FillRule inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
    
    # Attribute StrokeColor inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
    
    # Attribute StrokeWidth inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
    
    # Attribute StrokeWidthUnit inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
    
    # Attribute StrokeDashArray inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
    
    # Attribute Text inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
    
    # Attribute FontFamily inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
    
    # Attribute FontSize inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
    
    # Attribute FontSizeUnit inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
    
    # Attribute FontStyle inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
    
    # Attribute Locked inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
    
    # Attribute ID inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
    
    # Attribute TheZ inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
    
    # Attribute TheT inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
    
    # Attribute TheC inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
    
    # Attribute X uses Python identifier X
    __X = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'X'), 'X', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_70_X', pyxb.binding.datatypes.float, required=True)
    __X._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3976, 10)
    __X._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3976, 10)
    
    X = property(__X.value, __X.set, None, '\n                The X value of the left edge or the rectangle. [units pixels]\n              ')

    
    # Attribute Y uses Python identifier Y
    __Y = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'Y'), 'Y', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_70_Y', pyxb.binding.datatypes.float, required=True)
    __Y._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3983, 10)
    __Y._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3983, 10)
    
    Y = property(__Y.value, __Y.set, None, '\n                The y value of the top edge or the rectangle. [units pixels]\n              ')

    
    # Attribute Width uses Python identifier Width
    __Width = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'Width'), 'Width', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_70_Width', pyxb.binding.datatypes.float, required=True)
    __Width._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3990, 10)
    __Width._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3990, 10)
    
    Width = property(__Width.value, __Width.set, None, '\n                The width of the rectangle. [units pixels]\n              ')

    
    # Attribute Height uses Python identifier Height
    __Height = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'Height'), 'Height', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_70_Height', pyxb.binding.datatypes.float, required=True)
    __Height._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3997, 10)
    __Height._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3997, 10)
    
    Height = property(__Height.value, __Height.set, None, '\n                The height of the rectangle. [units pixels]\n              ')

    _ElementMap.update({
        
    })
    _AttributeMap.update({
        __X.name() : __X,
        __Y.name() : __Y,
        __Width.name() : __Width,
        __Height.name() : __Height
    })
_module_typeBindings.CTD_ANON_70 = CTD_ANON_70


# Complex type [anonymous] with content type ELEMENT_ONLY
class CTD_ANON_71 (Shape):
    """
        The Mask ROI shape is a link to a BinData object that is
        a BIT mask drawn on top of the image as an ROI. It is applied
        at the same scale, pixel to pixel, as the Image the ROI is
        applied to, unless a transform is applied at the shape level.
      """
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = None
    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4019, 4)
    _ElementMap = Shape._ElementMap.copy()
    _AttributeMap = Shape._AttributeMap.copy()
    # Base type is Shape
    
    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}BinData uses Python identifier BinData
    __BinData = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'BinData'), 'BinData', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_71_httpwww_openmicroscopy_orgSchemasOME2016_06BinData', False, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3320, 2), )

    
    BinData = property(__BinData.value, __BinData.set, None, 'The contents of this element are base64-encoded.  These are not CDATA sections, just a base64 stream.')

    
    # Element AnnotationRef ({http://www.openmicroscopy.org/Schemas/OME/2016-06}AnnotationRef) inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
    
    # Element Transform ({http://www.openmicroscopy.org/Schemas/OME/2016-06}Transform) inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
    
    # Attribute FillColor inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
    
    # Attribute FillRule inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
    
    # Attribute StrokeColor inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
    
    # Attribute StrokeWidth inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
    
    # Attribute StrokeWidthUnit inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
    
    # Attribute StrokeDashArray inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
    
    # Attribute Text inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
    
    # Attribute FontFamily inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
    
    # Attribute FontSize inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
    
    # Attribute FontSizeUnit inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
    
    # Attribute FontStyle inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
    
    # Attribute Locked inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
    
    # Attribute ID inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
    
    # Attribute TheZ inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
    
    # Attribute TheT inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
    
    # Attribute TheC inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
    
    # Attribute X uses Python identifier X
    __X = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'X'), 'X', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_71_X', pyxb.binding.datatypes.float, required=True)
    __X._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4025, 10)
    __X._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4025, 10)
    
    X = property(__X.value, __X.set, None, '\n                The X coordinate of the left side of the image. [units pixels]\n              ')

    
    # Attribute Y uses Python identifier Y
    __Y = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'Y'), 'Y', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_71_Y', pyxb.binding.datatypes.float, required=True)
    __Y._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4032, 10)
    __Y._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4032, 10)
    
    Y = property(__Y.value, __Y.set, None, '\n                The Y coordinate of the top side of the image. [units pixels]\n              ')

    
    # Attribute Width uses Python identifier Width
    __Width = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'Width'), 'Width', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_71_Width', pyxb.binding.datatypes.float, required=True)
    __Width._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4039, 10)
    __Width._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4039, 10)
    
    Width = property(__Width.value, __Width.set, None, '\n                The width of the mask. [units pixels]\n              ')

    
    # Attribute Height uses Python identifier Height
    __Height = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'Height'), 'Height', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_71_Height', pyxb.binding.datatypes.float, required=True)
    __Height._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4046, 10)
    __Height._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4046, 10)
    
    Height = property(__Height.value, __Height.set, None, '\n                The height of the mask. [units pixels]\n              ')

    _ElementMap.update({
        __BinData.name() : __BinData
    })
    _AttributeMap.update({
        __X.name() : __X,
        __Y.name() : __Y,
        __Width.name() : __Width,
        __Height.name() : __Height
    })
_module_typeBindings.CTD_ANON_71 = CTD_ANON_71


# Complex type [anonymous] with content type ELEMENT_ONLY
class CTD_ANON_72 (Shape):
    """"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = None
    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4062, 4)
    _ElementMap = Shape._ElementMap.copy()
    _AttributeMap = Shape._AttributeMap.copy()
    # Base type is Shape
    
    # Element AnnotationRef ({http://www.openmicroscopy.org/Schemas/OME/2016-06}AnnotationRef) inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
    
    # Element Transform ({http://www.openmicroscopy.org/Schemas/OME/2016-06}Transform) inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
    
    # Attribute FillColor inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
    
    # Attribute FillRule inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
    
    # Attribute StrokeColor inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
    
    # Attribute StrokeWidth inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
    
    # Attribute StrokeWidthUnit inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
    
    # Attribute StrokeDashArray inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
    
    # Attribute Text inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
    
    # Attribute FontFamily inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
    
    # Attribute FontSize inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
    
    # Attribute FontSizeUnit inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
    
    # Attribute FontStyle inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
    
    # Attribute Locked inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
    
    # Attribute ID inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
    
    # Attribute TheZ inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
    
    # Attribute TheT inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
    
    # Attribute TheC inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
    
    # Attribute X uses Python identifier X
    __X = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'X'), 'X', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_72_X', pyxb.binding.datatypes.float, required=True)
    __X._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4065, 10)
    __X._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4065, 10)
    
    X = property(__X.value, __X.set, None, '\n                The X coordinate of the point. [units pixels]\n              ')

    
    # Attribute Y uses Python identifier Y
    __Y = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'Y'), 'Y', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_72_Y', pyxb.binding.datatypes.float, required=True)
    __Y._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4072, 10)
    __Y._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4072, 10)
    
    Y = property(__Y.value, __Y.set, None, '\n                The Y coordinate of the point. [units pixels]\n              ')

    _ElementMap.update({
        
    })
    _AttributeMap.update({
        __X.name() : __X,
        __Y.name() : __Y
    })
_module_typeBindings.CTD_ANON_72 = CTD_ANON_72


# Complex type [anonymous] with content type ELEMENT_ONLY
class CTD_ANON_73 (Shape):
    """
        A simple ellipse object. If rotation is required apply a
        transformation at the Shape level.
      """
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = None
    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4092, 4)
    _ElementMap = Shape._ElementMap.copy()
    _AttributeMap = Shape._AttributeMap.copy()
    # Base type is Shape
    
    # Element AnnotationRef ({http://www.openmicroscopy.org/Schemas/OME/2016-06}AnnotationRef) inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
    
    # Element Transform ({http://www.openmicroscopy.org/Schemas/OME/2016-06}Transform) inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
    
    # Attribute FillColor inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
    
    # Attribute FillRule inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
    
    # Attribute StrokeColor inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
    
    # Attribute StrokeWidth inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
    
    # Attribute StrokeWidthUnit inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
    
    # Attribute StrokeDashArray inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
    
    # Attribute Text inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
    
    # Attribute FontFamily inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
    
    # Attribute FontSize inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
    
    # Attribute FontSizeUnit inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
    
    # Attribute FontStyle inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
    
    # Attribute Locked inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
    
    # Attribute ID inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
    
    # Attribute TheZ inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
    
    # Attribute TheT inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
    
    # Attribute TheC inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
    
    # Attribute X uses Python identifier X
    __X = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'X'), 'X', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_73_X', pyxb.binding.datatypes.float, required=True)
    __X._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4095, 10)
    __X._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4095, 10)
    
    X = property(__X.value, __X.set, None, '\n                The X coordinate of the center of the ellipse. [units pixels]\n              ')

    
    # Attribute Y uses Python identifier Y
    __Y = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'Y'), 'Y', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_73_Y', pyxb.binding.datatypes.float, required=True)
    __Y._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4102, 10)
    __Y._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4102, 10)
    
    Y = property(__Y.value, __Y.set, None, '\n                The Y coordinate of the center of the ellipse. [units pixels]\n              ')

    
    # Attribute RadiusX uses Python identifier RadiusX
    __RadiusX = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'RadiusX'), 'RadiusX', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_73_RadiusX', pyxb.binding.datatypes.float, required=True)
    __RadiusX._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4109, 10)
    __RadiusX._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4109, 10)
    
    RadiusX = property(__RadiusX.value, __RadiusX.set, None, '\n                The horizontal radius of the ellipse. [units pixels]\n              ')

    
    # Attribute RadiusY uses Python identifier RadiusY
    __RadiusY = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'RadiusY'), 'RadiusY', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_73_RadiusY', pyxb.binding.datatypes.float, required=True)
    __RadiusY._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4116, 10)
    __RadiusY._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4116, 10)
    
    RadiusY = property(__RadiusY.value, __RadiusY.set, None, '\n                The vertical radius of the ellipse. [units pixels]\n              ')

    _ElementMap.update({
        
    })
    _AttributeMap.update({
        __X.name() : __X,
        __Y.name() : __Y,
        __RadiusX.name() : __RadiusX,
        __RadiusY.name() : __RadiusY
    })
_module_typeBindings.CTD_ANON_73 = CTD_ANON_73


# Complex type [anonymous] with content type ELEMENT_ONLY
class CTD_ANON_74 (Shape):
    """
        A straight line defined by it's end points.
      """
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = None
    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4135, 4)
    _ElementMap = Shape._ElementMap.copy()
    _AttributeMap = Shape._AttributeMap.copy()
    # Base type is Shape
    
    # Element AnnotationRef ({http://www.openmicroscopy.org/Schemas/OME/2016-06}AnnotationRef) inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
    
    # Element Transform ({http://www.openmicroscopy.org/Schemas/OME/2016-06}Transform) inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
    
    # Attribute FillColor inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
    
    # Attribute FillRule inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
    
    # Attribute StrokeColor inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
    
    # Attribute StrokeWidth inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
    
    # Attribute StrokeWidthUnit inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
    
    # Attribute StrokeDashArray inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
    
    # Attribute Text inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
    
    # Attribute FontFamily inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
    
    # Attribute FontSize inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
    
    # Attribute FontSizeUnit inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
    
    # Attribute FontStyle inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
    
    # Attribute Locked inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
    
    # Attribute ID inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
    
    # Attribute TheZ inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
    
    # Attribute TheT inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
    
    # Attribute TheC inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
    
    # Attribute X1 uses Python identifier X1
    __X1 = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'X1'), 'X1', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_74_X1', pyxb.binding.datatypes.float, required=True)
    __X1._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4138, 10)
    __X1._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4138, 10)
    
    X1 = property(__X1.value, __X1.set, None, ' The X coordinate of the start of the line. [units pixels]\n              ')

    
    # Attribute Y1 uses Python identifier Y1
    __Y1 = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'Y1'), 'Y1', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_74_Y1', pyxb.binding.datatypes.float, required=True)
    __Y1._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4144, 10)
    __Y1._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4144, 10)
    
    Y1 = property(__Y1.value, __Y1.set, None, ' The Y coordinate of the start of the line. [units pixels]\n              ')

    
    # Attribute X2 uses Python identifier X2
    __X2 = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'X2'), 'X2', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_74_X2', pyxb.binding.datatypes.float, required=True)
    __X2._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4150, 10)
    __X2._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4150, 10)
    
    X2 = property(__X2.value, __X2.set, None, ' The X coordinate of the end of the line. [units pixels]\n              ')

    
    # Attribute Y2 uses Python identifier Y2
    __Y2 = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'Y2'), 'Y2', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_74_Y2', pyxb.binding.datatypes.float, required=True)
    __Y2._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4156, 10)
    __Y2._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4156, 10)
    
    Y2 = property(__Y2.value, __Y2.set, None, ' The Y coordinate of the end of the line. [units pixels]\n              ')

    
    # Attribute MarkerStart uses Python identifier MarkerStart
    __MarkerStart = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'MarkerStart'), 'MarkerStart', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_74_MarkerStart', _module_typeBindings.Marker)
    __MarkerStart._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4162, 10)
    __MarkerStart._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4162, 10)
    
    MarkerStart = property(__MarkerStart.value, __MarkerStart.set, None, None)

    
    # Attribute MarkerEnd uses Python identifier MarkerEnd
    __MarkerEnd = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'MarkerEnd'), 'MarkerEnd', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_74_MarkerEnd', _module_typeBindings.Marker)
    __MarkerEnd._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4163, 10)
    __MarkerEnd._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4163, 10)
    
    MarkerEnd = property(__MarkerEnd.value, __MarkerEnd.set, None, None)

    _ElementMap.update({
        
    })
    _AttributeMap.update({
        __X1.name() : __X1,
        __Y1.name() : __Y1,
        __X2.name() : __X2,
        __Y2.name() : __Y2,
        __MarkerStart.name() : __MarkerStart,
        __MarkerEnd.name() : __MarkerEnd
    })
_module_typeBindings.CTD_ANON_74 = CTD_ANON_74


# Complex type [anonymous] with content type ELEMENT_ONLY
class CTD_ANON_75 (Shape):
    """
        The Polyline defines open shapes formed of straight
        lines. Note: Polyline uses counterclockwise winding (this is the
        default OpenGL behavior)
      """
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = None
    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4178, 4)
    _ElementMap = Shape._ElementMap.copy()
    _AttributeMap = Shape._AttributeMap.copy()
    # Base type is Shape
    
    # Element AnnotationRef ({http://www.openmicroscopy.org/Schemas/OME/2016-06}AnnotationRef) inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
    
    # Element Transform ({http://www.openmicroscopy.org/Schemas/OME/2016-06}Transform) inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
    
    # Attribute FillColor inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
    
    # Attribute FillRule inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
    
    # Attribute StrokeColor inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
    
    # Attribute StrokeWidth inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
    
    # Attribute StrokeWidthUnit inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
    
    # Attribute StrokeDashArray inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
    
    # Attribute Text inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
    
    # Attribute FontFamily inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
    
    # Attribute FontSize inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
    
    # Attribute FontSizeUnit inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
    
    # Attribute FontStyle inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
    
    # Attribute Locked inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
    
    # Attribute ID inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
    
    # Attribute TheZ inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
    
    # Attribute TheT inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
    
    # Attribute TheC inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
    
    # Attribute Points uses Python identifier Points
    __Points = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'Points'), 'Points', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_75_Points', pyxb.binding.datatypes.string, required=True)
    __Points._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4181, 10)
    __Points._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4181, 10)
    
    Points = property(__Points.value, __Points.set, None, ' The points of the polyline are defined as a list of comma\n              separated x,y coordinates seperated by spaces like "x1,y1 x2,y2 x3,y3" e.g.\n              "0,0 1,2 3,5" ')

    
    # Attribute MarkerStart uses Python identifier MarkerStart
    __MarkerStart = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'MarkerStart'), 'MarkerStart', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_75_MarkerStart', _module_typeBindings.Marker)
    __MarkerStart._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4188, 10)
    __MarkerStart._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4188, 10)
    
    MarkerStart = property(__MarkerStart.value, __MarkerStart.set, None, None)

    
    # Attribute MarkerEnd uses Python identifier MarkerEnd
    __MarkerEnd = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'MarkerEnd'), 'MarkerEnd', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_75_MarkerEnd', _module_typeBindings.Marker)
    __MarkerEnd._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4189, 10)
    __MarkerEnd._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4189, 10)
    
    MarkerEnd = property(__MarkerEnd.value, __MarkerEnd.set, None, None)

    _ElementMap.update({
        
    })
    _AttributeMap.update({
        __Points.name() : __Points,
        __MarkerStart.name() : __MarkerStart,
        __MarkerEnd.name() : __MarkerEnd
    })
_module_typeBindings.CTD_ANON_75 = CTD_ANON_75


# Complex type [anonymous] with content type ELEMENT_ONLY
class CTD_ANON_76 (Shape):
    """
        The Polygon defines closed shapes formed of straight
        lines. Note: Polygon uses counterclockwise winding (this is the
        default OpenGL behavior)
      """
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = None
    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4204, 4)
    _ElementMap = Shape._ElementMap.copy()
    _AttributeMap = Shape._AttributeMap.copy()
    # Base type is Shape
    
    # Element AnnotationRef ({http://www.openmicroscopy.org/Schemas/OME/2016-06}AnnotationRef) inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
    
    # Element Transform ({http://www.openmicroscopy.org/Schemas/OME/2016-06}Transform) inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
    
    # Attribute FillColor inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
    
    # Attribute FillRule inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
    
    # Attribute StrokeColor inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
    
    # Attribute StrokeWidth inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
    
    # Attribute StrokeWidthUnit inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
    
    # Attribute StrokeDashArray inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
    
    # Attribute Text inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
    
    # Attribute FontFamily inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
    
    # Attribute FontSize inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
    
    # Attribute FontSizeUnit inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
    
    # Attribute FontStyle inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
    
    # Attribute Locked inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
    
    # Attribute ID inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
    
    # Attribute TheZ inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
    
    # Attribute TheT inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
    
    # Attribute TheC inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
    
    # Attribute Points uses Python identifier Points
    __Points = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'Points'), 'Points', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_76_Points', pyxb.binding.datatypes.string, required=True)
    __Points._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4207, 10)
    __Points._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4207, 10)
    
    Points = property(__Points.value, __Points.set, None, ' The points of the Polygon are defined as a list of comma\n              separated x,y coordinates seperated by spaces like "x1,y1 x2,y2 x3,y3" e.g.\n              "0,0 1,2 3,5" ')

    _ElementMap.update({
        
    })
    _AttributeMap.update({
        __Points.name() : __Points
    })
_module_typeBindings.CTD_ANON_76 = CTD_ANON_76


# Complex type [anonymous] with content type ELEMENT_ONLY
class CTD_ANON_77 (Shape):
    """
        The text label. Any transformation should be applied at the
        shape level.
      """
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = None
    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4227, 4)
    _ElementMap = Shape._ElementMap.copy()
    _AttributeMap = Shape._AttributeMap.copy()
    # Base type is Shape
    
    # Element AnnotationRef ({http://www.openmicroscopy.org/Schemas/OME/2016-06}AnnotationRef) inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
    
    # Element Transform ({http://www.openmicroscopy.org/Schemas/OME/2016-06}Transform) inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
    
    # Attribute FillColor inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
    
    # Attribute FillRule inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
    
    # Attribute StrokeColor inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
    
    # Attribute StrokeWidth inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
    
    # Attribute StrokeWidthUnit inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
    
    # Attribute StrokeDashArray inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
    
    # Attribute Text inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
    
    # Attribute FontFamily inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
    
    # Attribute FontSize inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
    
    # Attribute FontSizeUnit inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
    
    # Attribute FontStyle inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
    
    # Attribute Locked inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
    
    # Attribute ID inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
    
    # Attribute TheZ inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
    
    # Attribute TheT inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
    
    # Attribute TheC inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
    
    # Attribute X uses Python identifier X
    __X = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'X'), 'X', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_77_X', pyxb.binding.datatypes.float, required=True)
    __X._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4230, 10)
    __X._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4230, 10)
    
    X = property(__X.value, __X.set, None, ' This defines the X coordinate of the current text position\n              of the first character in the string. [units pixels] ')

    
    # Attribute Y uses Python identifier Y
    __Y = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'Y'), 'Y', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_77_Y', pyxb.binding.datatypes.float, required=True)
    __Y._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4236, 10)
    __Y._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4236, 10)
    
    Y = property(__Y.value, __Y.set, None, ' This defines the Y coordinate of the current text position\n              of the first character in the string. [units pixels] ')

    _ElementMap.update({
        
    })
    _AttributeMap.update({
        __X.name() : __X,
        __Y.name() : __Y
    })
_module_typeBindings.CTD_ANON_77 = CTD_ANON_77


# Complex type {http://www.openmicroscopy.org/Schemas/OME/2016-06}NumericAnnotation with content type ELEMENT_ONLY
class NumericAnnotation (BasicAnnotation):
    """
        An abstract Numeric Annotation from which some others are derived.
      """
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'NumericAnnotation')
    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3518, 2)
    _ElementMap = BasicAnnotation._ElementMap.copy()
    _AttributeMap = BasicAnnotation._AttributeMap.copy()
    # Base type is BasicAnnotation
    
    # Element AnnotationRef ({http://www.openmicroscopy.org/Schemas/OME/2016-06}AnnotationRef) inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Annotation
    
    # Element Description ({http://www.openmicroscopy.org/Schemas/OME/2016-06}Description) inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Annotation
    
    # Attribute ID inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Annotation
    
    # Attribute Namespace_ inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Annotation
    
    # Attribute Annotator inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Annotation
    _ElementMap.update({
        
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.NumericAnnotation = NumericAnnotation
Namespace.addCategoryObject('typeBinding', 'NumericAnnotation', NumericAnnotation)


# Complex type [anonymous] with content type ELEMENT_ONLY
class CTD_ANON_78 (TypeAnnotation):
    """
        A file object annotation
      """
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = None
    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3561, 4)
    _ElementMap = TypeAnnotation._ElementMap.copy()
    _AttributeMap = TypeAnnotation._AttributeMap.copy()
    # Base type is TypeAnnotation
    
    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}BinaryFile uses Python identifier BinaryFile
    __BinaryFile = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'BinaryFile'), 'BinaryFile', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_78_httpwww_openmicroscopy_orgSchemasOME2016_06BinaryFile', False, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3362, 2), )

    
    BinaryFile = property(__BinaryFile.value, __BinaryFile.set, None, 'Describes a binary file.')

    
    # Element AnnotationRef ({http://www.openmicroscopy.org/Schemas/OME/2016-06}AnnotationRef) inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Annotation
    
    # Element Description ({http://www.openmicroscopy.org/Schemas/OME/2016-06}Description) inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Annotation
    
    # Attribute ID inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Annotation
    
    # Attribute Namespace_ inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Annotation
    
    # Attribute Annotator inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Annotation
    _ElementMap.update({
        __BinaryFile.name() : __BinaryFile
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.CTD_ANON_78 = CTD_ANON_78


# Complex type [anonymous] with content type ELEMENT_ONLY
class CTD_ANON_79 (TextAnnotation):
    """
        An general xml annotation. The contents of this is not processed as OME XML but should still be well-formed XML.
      """
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = None
    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3578, 4)
    _ElementMap = TextAnnotation._ElementMap.copy()
    _AttributeMap = TextAnnotation._AttributeMap.copy()
    # Base type is TextAnnotation
    
    # Element AnnotationRef ({http://www.openmicroscopy.org/Schemas/OME/2016-06}AnnotationRef) inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Annotation
    
    # Element Description ({http://www.openmicroscopy.org/Schemas/OME/2016-06}Description) inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Annotation
    
    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}Value uses Python identifier Value
    __Value = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'Value'), 'Value', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_79_httpwww_openmicroscopy_orgSchemasOME2016_06Value', False, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3582, 12), )

    
    Value = property(__Value.value, __Value.set, None, None)

    
    # Attribute ID inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Annotation
    
    # Attribute Namespace_ inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Annotation
    
    # Attribute Annotator inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Annotation
    _ElementMap.update({
        __Value.name() : __Value
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.CTD_ANON_79 = CTD_ANON_79


# Complex type [anonymous] with content type ELEMENT_ONLY
class CTD_ANON_80 (TextAnnotation):
    """
        A simple comment annotation
      """
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = None
    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3615, 4)
    _ElementMap = TextAnnotation._ElementMap.copy()
    _AttributeMap = TextAnnotation._AttributeMap.copy()
    # Base type is TextAnnotation
    
    # Element AnnotationRef ({http://www.openmicroscopy.org/Schemas/OME/2016-06}AnnotationRef) inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Annotation
    
    # Element Description ({http://www.openmicroscopy.org/Schemas/OME/2016-06}Description) inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Annotation
    
    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}Value uses Python identifier Value
    __Value = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'Value'), 'Value', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_80_httpwww_openmicroscopy_orgSchemasOME2016_06Value', False, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3619, 12), )

    
    Value = property(__Value.value, __Value.set, None, None)

    
    # Attribute ID inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Annotation
    
    # Attribute Namespace_ inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Annotation
    
    # Attribute Annotator inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Annotation
    _ElementMap.update({
        __Value.name() : __Value
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.CTD_ANON_80 = CTD_ANON_80


# Complex type [anonymous] with content type ELEMENT_ONLY
class CTD_ANON_81 (BasicAnnotation):
    """
        A simple boolean annotation of type xsd:boolean
      """
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = None
    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3666, 4)
    _ElementMap = BasicAnnotation._ElementMap.copy()
    _AttributeMap = BasicAnnotation._AttributeMap.copy()
    # Base type is BasicAnnotation
    
    # Element AnnotationRef ({http://www.openmicroscopy.org/Schemas/OME/2016-06}AnnotationRef) inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Annotation
    
    # Element Description ({http://www.openmicroscopy.org/Schemas/OME/2016-06}Description) inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Annotation
    
    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}Value uses Python identifier Value
    __Value = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'Value'), 'Value', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_81_httpwww_openmicroscopy_orgSchemasOME2016_06Value', False, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3670, 12), )

    
    Value = property(__Value.value, __Value.set, None, None)

    
    # Attribute ID inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Annotation
    
    # Attribute Namespace_ inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Annotation
    
    # Attribute Annotator inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Annotation
    _ElementMap.update({
        __Value.name() : __Value
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.CTD_ANON_81 = CTD_ANON_81


# Complex type [anonymous] with content type ELEMENT_ONLY
class CTD_ANON_82 (BasicAnnotation):
    """
        A date/time annotation of type xsd:dateTime
      """
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = None
    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3683, 4)
    _ElementMap = BasicAnnotation._ElementMap.copy()
    _AttributeMap = BasicAnnotation._AttributeMap.copy()
    # Base type is BasicAnnotation
    
    # Element AnnotationRef ({http://www.openmicroscopy.org/Schemas/OME/2016-06}AnnotationRef) inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Annotation
    
    # Element Description ({http://www.openmicroscopy.org/Schemas/OME/2016-06}Description) inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Annotation
    
    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}Value uses Python identifier Value
    __Value = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'Value'), 'Value', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_82_httpwww_openmicroscopy_orgSchemasOME2016_06Value', False, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3687, 12), )

    
    Value = property(__Value.value, __Value.set, None, None)

    
    # Attribute ID inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Annotation
    
    # Attribute Namespace_ inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Annotation
    
    # Attribute Annotator inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Annotation
    _ElementMap.update({
        __Value.name() : __Value
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.CTD_ANON_82 = CTD_ANON_82


# Complex type [anonymous] with content type ELEMENT_ONLY
class CTD_ANON_83 (TextAnnotation):
    """
        A tag annotation (represents a tag or a tagset)
      """
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = None
    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3700, 4)
    _ElementMap = TextAnnotation._ElementMap.copy()
    _AttributeMap = TextAnnotation._AttributeMap.copy()
    # Base type is TextAnnotation
    
    # Element AnnotationRef ({http://www.openmicroscopy.org/Schemas/OME/2016-06}AnnotationRef) inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Annotation
    
    # Element Description ({http://www.openmicroscopy.org/Schemas/OME/2016-06}Description) inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Annotation
    
    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}Value uses Python identifier Value
    __Value = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'Value'), 'Value', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_83_httpwww_openmicroscopy_orgSchemasOME2016_06Value', False, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3704, 12), )

    
    Value = property(__Value.value, __Value.set, None, None)

    
    # Attribute ID inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Annotation
    
    # Attribute Namespace_ inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Annotation
    
    # Attribute Annotator inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Annotation
    _ElementMap.update({
        __Value.name() : __Value
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.CTD_ANON_83 = CTD_ANON_83


# Complex type [anonymous] with content type ELEMENT_ONLY
class CTD_ANON_84 (BasicAnnotation):
    """
        A ontology term annotation
      """
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = None
    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3717, 4)
    _ElementMap = BasicAnnotation._ElementMap.copy()
    _AttributeMap = BasicAnnotation._AttributeMap.copy()
    # Base type is BasicAnnotation
    
    # Element AnnotationRef ({http://www.openmicroscopy.org/Schemas/OME/2016-06}AnnotationRef) inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Annotation
    
    # Element Description ({http://www.openmicroscopy.org/Schemas/OME/2016-06}Description) inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Annotation
    
    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}Value uses Python identifier Value
    __Value = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'Value'), 'Value', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_84_httpwww_openmicroscopy_orgSchemasOME2016_06Value', False, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3721, 12), )

    
    Value = property(__Value.value, __Value.set, None, None)

    
    # Attribute ID inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Annotation
    
    # Attribute Namespace_ inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Annotation
    
    # Attribute Annotator inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Annotation
    _ElementMap.update({
        __Value.name() : __Value
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.CTD_ANON_84 = CTD_ANON_84


# Complex type [anonymous] with content type ELEMENT_ONLY
class CTD_ANON_85 (NumericAnnotation):
    """
        A simple numerical annotation of type xsd:long
      """
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = None
    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3632, 4)
    _ElementMap = NumericAnnotation._ElementMap.copy()
    _AttributeMap = NumericAnnotation._AttributeMap.copy()
    # Base type is NumericAnnotation
    
    # Element AnnotationRef ({http://www.openmicroscopy.org/Schemas/OME/2016-06}AnnotationRef) inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Annotation
    
    # Element Description ({http://www.openmicroscopy.org/Schemas/OME/2016-06}Description) inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Annotation
    
    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}Value uses Python identifier Value
    __Value = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'Value'), 'Value', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_85_httpwww_openmicroscopy_orgSchemasOME2016_06Value', False, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3636, 12), )

    
    Value = property(__Value.value, __Value.set, None, None)

    
    # Attribute ID inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Annotation
    
    # Attribute Namespace_ inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Annotation
    
    # Attribute Annotator inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Annotation
    _ElementMap.update({
        __Value.name() : __Value
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.CTD_ANON_85 = CTD_ANON_85


# Complex type [anonymous] with content type ELEMENT_ONLY
class CTD_ANON_86 (NumericAnnotation):
    """
        A simple numerical annotation of type xsd:double
      """
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = None
    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3649, 4)
    _ElementMap = NumericAnnotation._ElementMap.copy()
    _AttributeMap = NumericAnnotation._AttributeMap.copy()
    # Base type is NumericAnnotation
    
    # Element AnnotationRef ({http://www.openmicroscopy.org/Schemas/OME/2016-06}AnnotationRef) inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Annotation
    
    # Element Description ({http://www.openmicroscopy.org/Schemas/OME/2016-06}Description) inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Annotation
    
    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}Value uses Python identifier Value
    __Value = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'Value'), 'Value', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_86_httpwww_openmicroscopy_orgSchemasOME2016_06Value', False, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3653, 12), )

    
    Value = property(__Value.value, __Value.set, None, None)

    
    # Attribute ID inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Annotation
    
    # Attribute Namespace_ inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Annotation
    
    # Attribute Annotator inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Annotation
    _ElementMap.update({
        __Value.name() : __Value
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.CTD_ANON_86 = CTD_ANON_86


MetadataOnly = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'MetadataOnly'), pyxb.binding.datatypes.anyType, documentation='\n        This place holder means there is on pixel data in this file.\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 784, 2))
Namespace.addCategoryObject('elementBinding', MetadataOnly.name().localName(), MetadataOnly)

LightPath = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'LightPath'), CTD_ANON_, documentation='A description of the light path', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2411, 2))
Namespace.addCategoryObject('elementBinding', LightPath.name().localName(), LightPath)

Rights = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'Rights'), CTD_ANON_2, documentation='\n        The rights holder of this data and the rights held.\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2794, 2))
Namespace.addCategoryObject('elementBinding', Rights.name().localName(), Rights)

StructuredAnnotations = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'StructuredAnnotations'), CTD_ANON_3, documentation='\n        An unordered collection of annotation attached to objects in the OME data model.\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3413, 2))
Namespace.addCategoryObject('elementBinding', StructuredAnnotations.name().localName(), StructuredAnnotations)

OME = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'OME'), CTD_ANON_6, documentation='\n        The OME element is a container for all information objects accessible by OME.\n        These information objects include descriptions of the imaging experiments\n        and the people who perform them, descriptions of the microscope, the resulting\n        images and how they were acquired, the analyses performed on those images,\n        and the analysis results themselves.\n        An OME file may contain any or all of this information.\n\n        With the creation of the Metadata Only Companion OME-XML and Binary Only OME-TIFF files\n        the top level OME node has changed slightly.\n        It can EITHER:\n        Contain all the previously expected elements\n        OR:\n        Contain a single BinaryOnly element that points at\n        its Metadata Only Companion OME-XML file.\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 40, 2))
Namespace.addCategoryObject('elementBinding', OME.name().localName(), OME)

Plane = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'Plane'), CTD_ANON_8, documentation='\n        The Plane object holds microscope stage and image timing data\n        for a given channel/z-section/timepoint.\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 478, 2))
Namespace.addCategoryObject('elementBinding', Plane.name().localName(), Plane)

TiffData = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'TiffData'), CTD_ANON_9, documentation='\n        This described the location of the pixel data in a tiff file.\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 792, 2))
Namespace.addCategoryObject('elementBinding', TiffData.name().localName(), TiffData)

StageLabel = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'StageLabel'), CTD_ANON_11, documentation="\n        The StageLabel is used to specify a name and position for a stage position in the microscope's reference frame.\n      ", location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 871, 2))
Namespace.addCategoryObject('elementBinding', StageLabel.name().localName(), StageLabel)

Microscope = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'Microscope'), CTD_ANON_12, documentation="The microscope's manufacturer specification.", location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1016, 2))
Namespace.addCategoryObject('elementBinding', Microscope.name().localName(), Microscope)

ImagingEnvironment = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'ImagingEnvironment'), CTD_ANON_13, documentation='\n        This describes the environment that the biological sample was in\n        during the experiment.\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1041, 2))
Namespace.addCategoryObject('elementBinding', ImagingEnvironment.name().localName(), ImagingEnvironment)

TransmittanceRange = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'TransmittanceRange'), CTD_ANON_14, documentation='\n        This records the range of wavelengths that are transmitted by the filter. It also records the maximum amount of light transmitted.\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2325, 2))
Namespace.addCategoryObject('elementBinding', TransmittanceRange.name().localName(), TransmittanceRange)

External = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'External'), CTD_ANON_15, documentation='Describes a file location.  Can optionally specify a portion of a file using Offset and a ReadLength.\n      If Offset and ReadLength are specified in conjuction with Compression, then they point into the uncompressed file.\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3288, 2))
Namespace.addCategoryObject('elementBinding', External.name().localName(), External)

BinaryFile = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'BinaryFile'), CTD_ANON_16, documentation='Describes a binary file.', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3362, 2))
Namespace.addCategoryObject('elementBinding', BinaryFile.name().localName(), BinaryFile)

Image = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'Image'), CTD_ANON_17, documentation="\n        This element describes the actual image and its meta-data.\n        The elements that are references (ending in Ref or Settings) refer to\n        elements defined outside of the Image element. Ref elements are simple\n        links, while Settings elements are links with additional values.\n\n        If any of the required Image attributes or elements are missing, its\n        guaranteed to be an invalid document. The required attributes and\n        elements are ID and Pixels.\n\n        ExperimenterRef is required for all Images with well formed LSIDs.\n        ImageType is a vendor-specific designation of the type of image this is.\n        Examples of ImageType include 'STK', 'SoftWorx', etc.\n        The Name attributes are in all cases the name of the element\n        instance. In this case, the name of the image, not necessarily the filename.\n        Physical size of pixels are microns[\xb5m].\n      ", location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 209, 2))
Namespace.addCategoryObject('elementBinding', Image.name().localName(), Image)

Pixels = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'Pixels'), CTD_ANON_18, documentation="\n        Pixels is going to be removed in the future, but it is still required.\n\n        This is just notice that the contents of Pixels will be\n        moved up to Image in a future release. This is because there\n        has only been 1 Pixels object in each Image for some time.\n        The concept of multiple Pixels sets for one Image failed to\n        take off. It is therefore redundant.\n\n        The Image will be unreadable if any of the required Pixel attributes are missing.\n\n        The Pixels themselves can be stored within the OME-XML compressed by plane, and encoded\n        in Base64.\n        Or the Pixels may be stored in TIFF format.\n\n        The Pixels element should contain a list of BinData or TiffData, each containing a\n        single plane of pixels. These Pixels elements, when read in document order,\n        must produce a 5-D pixel array of the size specified in this element, and in the\n        dimension order specified by 'DimensionOrder'.\n\n        All of the values in the Pixels object when present should match the same value\n        stored in any associated TIFF format (e.g. SizeX should be the same). Where there\n        is a mismatch our readers will take the value from the TIFF structure as overriding\n        the value in the OME-XML. This is simply a pragmatic decision as it increases the\n        likelihood of reading data from a slightly incorrect file.\n      ", location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 307, 2))
Namespace.addCategoryObject('elementBinding', Pixels.name().localName(), Pixels)

Channel = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'Channel'), CTD_ANON_19, documentation="\n        There must be one per channel in the Image, even for a single-plane image.\n        And information about how each of them was acquired is stored in the various optional *Ref elements.  Each Logical Channel is composed of one or more\n        ChannelComponents.  For example, an entire spectrum in an FTIR experiment may be stored in a single Logical Channel with each discrete wavenumber of the spectrum\n        constituting a ChannelComponent of the FTIR Logical Channel.  An RGB image where the Red, Green and Blue components do not reflect discrete probes but are\n        instead the output of a color camera would be treated similarly - one Logical channel with three ChannelComponents in this case.\n        The total number of ChannelComponents for a set of pixels must equal SizeC.\n        The IlluminationType attribute is a string enumeration which may be set to 'Transmitted', 'Epifluorescence', 'Oblique', or 'NonLinear'.\n        The user interface logic for labeling a given channel for the user should use the first existing attribute in the following sequence:\n        Name -> Fluor -> EmissionWavelength -> ChannelComponent/Index.\n      ", location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 592, 2))
Namespace.addCategoryObject('elementBinding', Channel.name().localName(), Channel)

MicrobeamManipulation = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'MicrobeamManipulation'), CTD_ANON_20, documentation='\n        Defines a microbeam operation type and the region of the image it was applied to.\n        The LightSourceRef element is a reference to a LightSource specified in the Instrument element which was used for a technique other than illumination for\n        the purpose of imaging. For example, a laser used for photobleaching.\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 920, 2))
Namespace.addCategoryObject('elementBinding', MicrobeamManipulation.name().localName(), MicrobeamManipulation)

Instrument = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'Instrument'), CTD_ANON_21, documentation="\n        This element describes the instrument used to capture the Image.\n        It is primarily a container for manufacturer's model and catalog\n        numbers for the Microscope, LightSource, Detector, Objective and\n        Filters components.\n        The Objective element contains the additional elements LensNA and Magnification.\n        The Filters element can be composed either of separate excitation,\n        emission filters and a dichroic mirror or a single filter set.\n        Within the Image itself, a reference is made to this one Filter element.\n        There may be multiple light sources, detectors, objectives and filters on a microscope.\n        Each of these has their own ID attribute, which can be referred to from Channel.\n        It is understood that the light path configuration can be different\n        for each channel, but cannot be different for each timepoint or\n        each plane of an XYZ stack.\n      ", location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 979, 2))
Namespace.addCategoryObject('elementBinding', Instrument.name().localName(), Instrument)

Project = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'Project'), CTD_ANON_22, documentation='\n        The Project ID is required.\n        Datasets can be grouped into projects using a many-to-many relationship.\n        A Dataset may belong to one or more Projects by including one or more ProjectRef elements which refer to Project IDs.\n        Projects do not directly contain images - only by virtue of containing datasets, which themselves contain images.\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1101, 2))
Namespace.addCategoryObject('elementBinding', Project.name().localName(), Project)

ExperimenterGroup = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'ExperimenterGroup'), CTD_ANON_23, documentation='\n        The ExperimenterGroupID is required.\n        Information should ideally be specified for at least one Leader as a contact for the group.\n        The Leaders are themselves Experimenters.\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1142, 2))
Namespace.addCategoryObject('elementBinding', ExperimenterGroup.name().localName(), ExperimenterGroup)

Leader = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'Leader'), CTD_ANON_24, documentation='\n        Contact information for a ExperimenterGroup leader specified using a reference\n        to an Experimenter element defined elsewhere in the document.\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1185, 2))
Namespace.addCategoryObject('elementBinding', Leader.name().localName(), Leader)

Dataset = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'Dataset'), CTD_ANON_25, documentation='\n        An element specifying a collection of images that are always processed together.\n        Images can belong to more than one Dataset, and a Dataset may contain more than one Image.\n        Images contain one or more DatasetRef elements to specify what datasets they belong to.\n        Once a Dataset has been processed in any way, its collection of images cannot be altered.\n        The ExperimenterRef and ExperimenterGroupRef elements specify the person and group this Dataset belongs to.\n        Projects may contain one or more Datasets, and Datasets may belong to one or more Projects.\n        This relationship is specified by listing DatasetRef elements within the Project element.\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1201, 2))
Namespace.addCategoryObject('elementBinding', Dataset.name().localName(), Dataset)

Experiment = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'Experiment'), CTD_ANON_26, documentation="\n        This element describes the type of experiment.  The required Type attribute must contain one or more entries from the following list:\n        FP FRET Time-lapse 4-D+ Screen Immunocytochemistry FISH Electrophysiology  Ion-Imaging Colocalization PGI/Documentation\n        FRAP Photoablation Optical-Trapping Photoactivation Fluorescence-Lifetime Spectral-Imaging Other\n        FP refers to fluorescent proteins, PGI/Documentation is not a 'data' image.\n        The optional Description element may contain free text to further describe the experiment.\n      ", location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1251, 2))
Namespace.addCategoryObject('elementBinding', Experiment.name().localName(), Experiment)

Experimenter = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'Experimenter'), CTD_ANON_27, documentation='\n        This element describes a person who performed an imaging experiment.\n        This person may also be a user of the OME system, in which case the UserName element contains their login name.\n        Experimenters may belong to one or more groups which are specified using one or more ExperimenterGroupRef elements.\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1320, 2))
Namespace.addCategoryObject('elementBinding', Experimenter.name().localName(), Experimenter)

Folder = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'Folder'), CTD_ANON_28, documentation='\n        An element specifying a possibly heterogeneous collection of data.\n        Folders may contain Folders so that data may be organized within a tree of Folders.\n        Data may be in multiple Folders but a Folder may not be in more than one other Folder.\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1377, 2))
Namespace.addCategoryObject('elementBinding', Folder.name().localName(), Folder)

Objective = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'Objective'), CTD_ANON_29, documentation="\n        A description of the microscope's objective lens.\n        Required elements include the lens numerical aperture,\n        and the magnification, both of which a floating\n        point (real) numbers.\n        The values are those that are fixed for a particular\n        objective: either because it has been manufactured to\n        this specification or the value has been measured on\n        this particular objective.\n        Correction: This is the type of correction coating applied to this lens.\n        Immersion: This is the types of immersion medium the lens is designed to\n        work with. It is not the same as 'Medium' in ObjectiveRef (a\n        single type) as here Immersion can have compound values like 'Multi'.\n        LensNA: The numerical aperture of the lens (as a float)\n        NominalMagnification: The specified magnification e.g. x10\n        CalibratedMagnification: The measured magnification e.g. x10.3\n        WorkingDistance: WorkingDistance of the lens.\n      ", location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2024, 2))
Namespace.addCategoryObject('elementBinding', Objective.name().localName(), Objective)

Detector = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'Detector'), CTD_ANON_30, documentation='\n        The type of detector used to capture the image.\n        The Detector ID can be used as a reference within the Channel element in the Image element.\n        The values stored in Detector represent the fixed values,\n        variable values modified during the acquisition go in DetectorSettings\n\n        Each attribute now has an indication of what type of detector\n        it applies to. This is preparatory work for cleaning up and\n        possibly splitting this object into sub-types.\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2144, 2))
Namespace.addCategoryObject('elementBinding', Detector.name().localName(), Detector)

FilterSet = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'FilterSet'), CTD_ANON_31, documentation='Filter set manufacturer specification', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2242, 2))
Namespace.addCategoryObject('elementBinding', FilterSet.name().localName(), FilterSet)

Filter = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'Filter'), CTD_ANON_32, documentation="\n        A filter is either an excitation or emission filters.\n        There should be one filter element specified per wavelength in the image.\n        The channel number associated with a filter set is specified in Channel.\n        It is based on the FilterSpec type, so has the required attributes Manufacturer, Model, and LotNumber.\n        It may also contain a Type attribute which may be set to\n        'LongPass', 'ShortPass', 'BandPass', 'MultiPass',\n        'Dichroic', 'NeutralDensity', 'Tuneable' or 'Other'.\n        It can be associated with an optional FilterWheel - Note: this is not the same as a FilterSet\n      ", location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2274, 2))
Namespace.addCategoryObject('elementBinding', Filter.name().localName(), Filter)

Dichroic = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'Dichroic'), CTD_ANON_33, documentation='The dichromatic beamsplitter or dichroic mirror used for this filter combination.', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2391, 2))
Namespace.addCategoryObject('elementBinding', Dichroic.name().localName(), Dichroic)

DichroicRef = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'DichroicRef'), CTD_ANON_34, location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2443, 2))
Namespace.addCategoryObject('elementBinding', DichroicRef.name().localName(), DichroicRef)

LightSourceGroup = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'LightSourceGroup'), LightSource, abstract=pyxb.binding.datatypes.boolean(1), location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2454, 2))
Namespace.addCategoryObject('elementBinding', LightSourceGroup.name().localName(), LightSourceGroup)

Pump = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'Pump'), CTD_ANON_35, documentation="\n        The Pump element is a reference to a LightSource.  It is used within the Laser element to specify the light source for the laser's pump (if any).\n      ", location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2778, 2))
Namespace.addCategoryObject('elementBinding', Pump.name().localName(), Pump)

ImageRef = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'ImageRef'), CTD_ANON_36, documentation='\n        The ImageRef element is a reference to an Image element.\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2844, 2))
Namespace.addCategoryObject('elementBinding', ImageRef.name().localName(), ImageRef)

MicrobeamManipulationRef = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'MicrobeamManipulationRef'), CTD_ANON_37, location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2867, 2))
Namespace.addCategoryObject('elementBinding', MicrobeamManipulationRef.name().localName(), MicrobeamManipulationRef)

ExperimentRef = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'ExperimentRef'), CTD_ANON_38, location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2876, 2))
Namespace.addCategoryObject('elementBinding', ExperimentRef.name().localName(), ExperimentRef)

ChannelRef = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'ChannelRef'), CTD_ANON_39, location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2885, 2))
Namespace.addCategoryObject('elementBinding', ChannelRef.name().localName(), ChannelRef)

ProjectRef = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'ProjectRef'), CTD_ANON_40, documentation='\n        There may be one or more of these in a Dataset.\n        This empty element has a required Project ID attribute that refers to Projects defined within the OME element.\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2894, 2))
Namespace.addCategoryObject('elementBinding', ProjectRef.name().localName(), ProjectRef)

ExperimenterRef = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'ExperimenterRef'), CTD_ANON_41, documentation='\n        This empty element has a required Experimenter ID and an optional DocumentID attribute which refers to one of the Experimenters defined within OME.\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2909, 2))
Namespace.addCategoryObject('elementBinding', ExperimenterRef.name().localName(), ExperimenterRef)

ExperimenterGroupRef = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'ExperimenterGroupRef'), CTD_ANON_42, documentation='This empty element has a reference (the ExperimenterGroup ID attribute) to a ExperimenterGroup defined within OME.', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2923, 2))
Namespace.addCategoryObject('elementBinding', ExperimenterGroupRef.name().localName(), ExperimenterGroupRef)

InstrumentRef = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'InstrumentRef'), CTD_ANON_43, documentation='\n        This empty element can be used (via the required Instrument ID attribute) to refer to an Instrument defined within OME.\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2935, 2))
Namespace.addCategoryObject('elementBinding', InstrumentRef.name().localName(), InstrumentRef)

DatasetRef = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'DatasetRef'), CTD_ANON_44, documentation='\n        The DatasetRef element refers to a Dataset by specifying the Dataset ID attribute.\n        One or more DatasetRef elements may be listed within the Image element to specify what Datasets\n        the Image belongs to.\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2949, 2))
Namespace.addCategoryObject('elementBinding', DatasetRef.name().localName(), DatasetRef)

FolderRef = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'FolderRef'), CTD_ANON_45, documentation='\n        The FolderRef element refers to a Folder by specifying the Folder ID attribute.\n        One or more FolderRef elements may be listed within the Folder element to specify what Folders\n        the Folder contains. This tree hierarchy must be acyclic.\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2965, 2))
Namespace.addCategoryObject('elementBinding', FolderRef.name().localName(), FolderRef)

FilterSetRef = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'FilterSetRef'), CTD_ANON_46, location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2981, 2))
Namespace.addCategoryObject('elementBinding', FilterSetRef.name().localName(), FilterSetRef)

LightSourceSettings = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'LightSourceSettings'), CTD_ANON_47, documentation='', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3006, 2))
Namespace.addCategoryObject('elementBinding', LightSourceSettings.name().localName(), LightSourceSettings)

DetectorSettings = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'DetectorSettings'), CTD_ANON_48, documentation='\n        This holds the setting applied to a detector as well as a\n        reference to the detector.\n        The ID is the detector used in this case.\n        The values stored in DetectorSettings represent the variable values,\n        fixed values not modified during the acquisition go in Detector.\n\n        Each attribute now has an indication of what type of detector\n        it applies to. This is preparatory work for cleaning up and\n        possibly splitting this object into sub-types.\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3040, 2))
Namespace.addCategoryObject('elementBinding', DetectorSettings.name().localName(), DetectorSettings)

ObjectiveSettings = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'ObjectiveSettings'), CTD_ANON_49, documentation='\n        This holds the setting applied to an objective as well as a\n        reference to the objective.\n        The ID is the objective used in this case.\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3129, 2))
Namespace.addCategoryObject('elementBinding', ObjectiveSettings.name().localName(), ObjectiveSettings)

BinData = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'BinData'), CTD_ANON_50, documentation='The contents of this element are base64-encoded.  These are not CDATA sections, just a base64 stream.', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3320, 2))
Namespace.addCategoryObject('elementBinding', BinData.name().localName(), BinData)

AnnotationRef = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'AnnotationRef'), CTD_ANON_51, documentation='\n        The AnnotationRef element is a reference to an element derived\n        from the CommonAnnotation element.\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3435, 2))
Namespace.addCategoryObject('elementBinding', AnnotationRef.name().localName(), AnnotationRef)

ROI = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'ROI'), CTD_ANON_52, documentation="\n        A four dimensional 'Region of Interest'.\n        If they are not used, and the Image has more than one plane,\n        the entire set of planes is assumed to be included in the ROI.\n        Multiple ROIs may be specified.\n      ", location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3746, 2))
Namespace.addCategoryObject('elementBinding', ROI.name().localName(), ROI)

ShapeGroup = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'ShapeGroup'), Shape, abstract=pyxb.binding.datatypes.boolean(1), location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3795, 2))
Namespace.addCategoryObject('elementBinding', ShapeGroup.name().localName(), ShapeGroup)

ROIRef = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'ROIRef'), CTD_ANON_53, location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4247, 2))
Namespace.addCategoryObject('elementBinding', ROIRef.name().localName(), ROIRef)

Plate = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'Plate'), CTD_ANON_54, documentation='\n        This element identifies microtiter plates within a screen.\n        A plate can belong to more than one screen.\n        The Screen(s) that a plate belongs to are specified by the ScreenRef element.\n        The Plate ID and Name attributes are required.\n        The Wells in a plate are numbers from the top-left corner in a grid starting at zero.\n        i.e. The top-left well of a plate is index (0,0)\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4300, 2))
Namespace.addCategoryObject('elementBinding', Plate.name().localName(), Plate)

Reagent = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'Reagent'), CTD_ANON_55, documentation='\n        Reagent is used to describe a chemical or some other physical experimental parameter.\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4498, 2))
Namespace.addCategoryObject('elementBinding', Reagent.name().localName(), Reagent)

ReagentRef = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'ReagentRef'), CTD_ANON_56, location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4544, 2))
Namespace.addCategoryObject('elementBinding', ReagentRef.name().localName(), ReagentRef)

Screen = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'Screen'), CTD_ANON_57, documentation="\n        The Screen element is a grouping for Plates.\n        The required attribute is the Screen's Name and ID - both must be unique within the document.\n        The Screen element may contain an ExternalRef attribute that refers to an external database.\n        A description of the screen may be specified in the Description element.\n        Screens may contain overlapping sets of Plates i.e.      Screens and Plates have a many-to-many relationship.\n        Plates contain one or more ScreenRef elements to specify what screens they belong to.\n      ", location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4560, 2))
Namespace.addCategoryObject('elementBinding', Screen.name().localName(), Screen)

PlateAcquisition = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'PlateAcquisition'), CTD_ANON_59, documentation='\n        PlateAcquisition is used to describe a single acquisition run for a plate.\n        This object is used to record the set of images acquired in a single\n        acquisition run. The Images for this run are linked to PlateAcquisition\n        through WellSample.\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4660, 2))
Namespace.addCategoryObject('elementBinding', PlateAcquisition.name().localName(), PlateAcquisition)

Well = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'Well'), CTD_ANON_60, documentation='\n        A Well is a component of the Well/Plate/Screen construct to describe screening applications.\n        A Well has a number of WellSample elements that link to the Images collected in this well.\n        The ReagentRef links any Reagents that were used in this Well. A well is part of only one Plate.\n        The origin for the row and column identifiers is the top left corner of the plate starting at zero.\n        i.e The top left well of a plate is index (0,0)\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4726, 2))
Namespace.addCategoryObject('elementBinding', Well.name().localName(), Well)

WellSample = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'WellSample'), CTD_ANON_61, documentation='\n        WellSample is an individual image that has been captured within a Well.\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4810, 2))
Namespace.addCategoryObject('elementBinding', WellSample.name().localName(), WellSample)

WellSampleRef = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'WellSampleRef'), CTD_ANON_62, documentation='\n        The WellSampleRef element is a reference to a WellSample element.\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4883, 2))
Namespace.addCategoryObject('elementBinding', WellSampleRef.name().localName(), WellSampleRef)

Laser = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'Laser'), CTD_ANON_63, documentation='\n        Laser types are specified using two attributes - the Type and the LaserMedium.\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2497, 2))
Namespace.addCategoryObject('elementBinding', Laser.name().localName(), Laser)

Arc = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'Arc'), CTD_ANON_64, documentation='\n        The Arc element is used to describe various kinds of Arc lamps - Hg, Xe, HgXe.\n        The Power of the Arc is now stored in the LightSource.\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2658, 2))
Namespace.addCategoryObject('elementBinding', Arc.name().localName(), Arc)

Filament = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'Filament'), CTD_ANON_65, documentation='\n        The Filament element is used to describe various kinds of filament bulbs such as Incadescent or Halogen.\n        The Power of the Filament is now stored in the LightSource.\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2688, 2))
Namespace.addCategoryObject('elementBinding', Filament.name().localName(), Filament)

LightEmittingDiode = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'LightEmittingDiode'), CTD_ANON_66, documentation="\n        The LightEmittingDiode element is used to describe\n        various kinds of LED lamps.\n\n        As the LightEmittingDiode is inside a LightSource it already has\n        available the values from ManufacturerSpec\n        (Manufacturer, Model, SerialNumber, LotNumber)\n        And the values from LightSource which includes Power in milliwatts\n\n        We have looked at extending this element but have had a problem\n        producing a generic solution.\n\n        Possible attributes talked about adding include:\n        Power in lumens - but this is complicated by multi-channel\n        devices like CoolLED where each channel's power is different\n        Wavelength Range - not a simple value so would require\n        multiple attributes or a child element\n        Angle of Projection - this would be further affected by the\n        optics used for filtering the naked LED or that combine\n        power from multiple devices\n\n        These values are further affected if you over-drive the LED\n        resulting in a more complex system\n\n        Another issue is that LED's may not be used directly for\n        illumination but as drivers for secondary emissions from doped\n        fiber optics. This would require the fiber optics to be modeled.\n\n        Thanks to Paul Goodwin of Applied Precision of information about\n        this topic.\n      ", location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2717, 2))
Namespace.addCategoryObject('elementBinding', LightEmittingDiode.name().localName(), LightEmittingDiode)

GenericExcitationSource = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'GenericExcitationSource'), CTD_ANON_67, documentation='\n        The GenericExcitationSource element is used to represent\n        a source as a collection of key/value pairs, stored\n        in a Map. The other lightsource objects should\n        always be used in preference to this if possible.\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2758, 2))
Namespace.addCategoryObject('elementBinding', GenericExcitationSource.name().localName(), GenericExcitationSource)

ListAnnotation = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'ListAnnotation'), CTD_ANON_68, documentation='\n        This annotation is a grouping object. It uses the sequence of\n        annotation refs from the base Annotation to form the list.\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3594, 2))
Namespace.addCategoryObject('elementBinding', ListAnnotation.name().localName(), ListAnnotation)

MapAnnotation = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'MapAnnotation'), CTD_ANON_69, documentation='\n        An map annotation. The contents of this is a list of key/value pairs.\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3727, 2))
Namespace.addCategoryObject('elementBinding', MapAnnotation.name().localName(), MapAnnotation)

Rectangle = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'Rectangle'), CTD_ANON_70, documentation='\n        A simple rectangle object. If rotation is required apply a\n        transformation at the Shape level.\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3965, 2))
Namespace.addCategoryObject('elementBinding', Rectangle.name().localName(), Rectangle)

Mask = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'Mask'), CTD_ANON_71, documentation='\n        The Mask ROI shape is a link to a BinData object that is\n        a BIT mask drawn on top of the image as an ROI. It is applied\n        at the same scale, pixel to pixel, as the Image the ROI is\n        applied to, unless a transform is applied at the shape level.\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4009, 2))
Namespace.addCategoryObject('elementBinding', Mask.name().localName(), Mask)

Point = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'Point'), CTD_ANON_72, documentation='', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4058, 2))
Namespace.addCategoryObject('elementBinding', Point.name().localName(), Point)

Ellipse = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'Ellipse'), CTD_ANON_73, documentation='\n        A simple ellipse object. If rotation is required apply a\n        transformation at the Shape level.\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4084, 2))
Namespace.addCategoryObject('elementBinding', Ellipse.name().localName(), Ellipse)

Line = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'Line'), CTD_ANON_74, documentation="\n        A straight line defined by it's end points.\n      ", location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4128, 2))
Namespace.addCategoryObject('elementBinding', Line.name().localName(), Line)

Polyline = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'Polyline'), CTD_ANON_75, documentation='\n        The Polyline defines open shapes formed of straight\n        lines. Note: Polyline uses counterclockwise winding (this is the\n        default OpenGL behavior)\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4169, 2))
Namespace.addCategoryObject('elementBinding', Polyline.name().localName(), Polyline)

Polygon = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'Polygon'), CTD_ANON_76, documentation='\n        The Polygon defines closed shapes formed of straight\n        lines. Note: Polygon uses counterclockwise winding (this is the\n        default OpenGL behavior)\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4195, 2))
Namespace.addCategoryObject('elementBinding', Polygon.name().localName(), Polygon)

Label = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'Label'), CTD_ANON_77, documentation='\n        The text label. Any transformation should be applied at the\n        shape level.\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4219, 2))
Namespace.addCategoryObject('elementBinding', Label.name().localName(), Label)

FileAnnotation = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'FileAnnotation'), CTD_ANON_78, documentation='\n        A file object annotation\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3554, 2))
Namespace.addCategoryObject('elementBinding', FileAnnotation.name().localName(), FileAnnotation)

XMLAnnotation = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'XMLAnnotation'), CTD_ANON_79, documentation='\n        An general xml annotation. The contents of this is not processed as OME XML but should still be well-formed XML.\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3571, 2))
Namespace.addCategoryObject('elementBinding', XMLAnnotation.name().localName(), XMLAnnotation)

CommentAnnotation = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'CommentAnnotation'), CTD_ANON_80, documentation='\n        A simple comment annotation\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3608, 2))
Namespace.addCategoryObject('elementBinding', CommentAnnotation.name().localName(), CommentAnnotation)

BooleanAnnotation = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'BooleanAnnotation'), CTD_ANON_81, documentation='\n        A simple boolean annotation of type xsd:boolean\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3659, 2))
Namespace.addCategoryObject('elementBinding', BooleanAnnotation.name().localName(), BooleanAnnotation)

TimestampAnnotation = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'TimestampAnnotation'), CTD_ANON_82, documentation='\n        A date/time annotation of type xsd:dateTime\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3676, 2))
Namespace.addCategoryObject('elementBinding', TimestampAnnotation.name().localName(), TimestampAnnotation)

TagAnnotation = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'TagAnnotation'), CTD_ANON_83, documentation='\n        A tag annotation (represents a tag or a tagset)\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3693, 2))
Namespace.addCategoryObject('elementBinding', TagAnnotation.name().localName(), TagAnnotation)

TermAnnotation = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'TermAnnotation'), CTD_ANON_84, documentation='\n        A ontology term annotation\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3710, 2))
Namespace.addCategoryObject('elementBinding', TermAnnotation.name().localName(), TermAnnotation)

LongAnnotation = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'LongAnnotation'), CTD_ANON_85, documentation='\n        A simple numerical annotation of type xsd:long\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3625, 2))
Namespace.addCategoryObject('elementBinding', LongAnnotation.name().localName(), LongAnnotation)

DoubleAnnotation = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'DoubleAnnotation'), CTD_ANON_86, documentation='\n        A simple numerical annotation of type xsd:double\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3642, 2))
Namespace.addCategoryObject('elementBinding', DoubleAnnotation.name().localName(), DoubleAnnotation)



Map._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'M'), CTD_ANON, scope=Map, documentation=' This is a key/value pair used to build up a Mapping. The\n          Element and Attribute name are kept to single letters to minimize the\n          length at the expense of readability as they are likely to occur many\n          times. ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1563, 6)))

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()
    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1563, 6))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(Map._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'M')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1563, 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)
Map._Automaton = _BuildAutomaton()




CTD_ANON_._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'ExcitationFilterRef'), FilterRef, scope=CTD_ANON_, documentation='\n              The Filters placed in the Excitation light path.\n            ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2418, 8)))

CTD_ANON_._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'EmissionFilterRef'), FilterRef, scope=CTD_ANON_, documentation='\n              The Filters placed in the Emission light path.\n            ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2427, 8)))

CTD_ANON_._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'DichroicRef'), CTD_ANON_34, scope=CTD_ANON_, location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2443, 2)))

CTD_ANON_._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'AnnotationRef'), CTD_ANON_51, scope=CTD_ANON_, documentation='\n        The AnnotationRef element is a reference to an element derived\n        from the CommonAnnotation element.\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3435, 2)))

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()
    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2418, 8))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2426, 8))
    counters.add(cc_1)
    cc_2 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2427, 8))
    counters.add(cc_2)
    cc_3 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2435, 8))
    counters.add(cc_3)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(CTD_ANON_._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'ExcitationFilterRef')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2418, 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_1, False))
    symbol = pyxb.binding.content.ElementUse(CTD_ANON_._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'DichroicRef')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2426, 8))
    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(CTD_ANON_._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'EmissionFilterRef')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2427, 8))
    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(CTD_ANON_._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'AnnotationRef')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2435, 8))
    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)
CTD_ANON_._Automaton = _BuildAutomaton_()




CTD_ANON_2._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'RightsHolder'), STD_ANON_23, scope=CTD_ANON_2, documentation=' The rights holder for this data. [plain-text multi-line string]\n            e.g. "Copyright (C) 2002 - 2016 Open Microscopy Environment"\n            ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2803, 8)))

CTD_ANON_2._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'RightsHeld'), STD_ANON_24, scope=CTD_ANON_2, documentation='\n              The rights held by the rights holder. [plain-text multi-line string]\n              e.g. "All rights reserved" or "Creative Commons Attribution 3.0 Unported License"\n            ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2815, 8)))

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()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2803, 8))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2815, 8))
    counters.add(cc_1)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(CTD_ANON_2._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'RightsHolder')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2803, 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_1, False))
    symbol = pyxb.binding.content.ElementUse(CTD_ANON_2._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'RightsHeld')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2815, 8))
    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)
CTD_ANON_2._Automaton = _BuildAutomaton_2()




CTD_ANON_3._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'FileAnnotation'), CTD_ANON_78, scope=CTD_ANON_3, documentation='\n        A file object annotation\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3554, 2)))

CTD_ANON_3._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'XMLAnnotation'), CTD_ANON_79, scope=CTD_ANON_3, documentation='\n        An general xml annotation. The contents of this is not processed as OME XML but should still be well-formed XML.\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3571, 2)))

CTD_ANON_3._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'ListAnnotation'), CTD_ANON_68, scope=CTD_ANON_3, documentation='\n        This annotation is a grouping object. It uses the sequence of\n        annotation refs from the base Annotation to form the list.\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3594, 2)))

CTD_ANON_3._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'CommentAnnotation'), CTD_ANON_80, scope=CTD_ANON_3, documentation='\n        A simple comment annotation\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3608, 2)))

CTD_ANON_3._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'LongAnnotation'), CTD_ANON_85, scope=CTD_ANON_3, documentation='\n        A simple numerical annotation of type xsd:long\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3625, 2)))

CTD_ANON_3._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'DoubleAnnotation'), CTD_ANON_86, scope=CTD_ANON_3, documentation='\n        A simple numerical annotation of type xsd:double\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3642, 2)))

CTD_ANON_3._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'BooleanAnnotation'), CTD_ANON_81, scope=CTD_ANON_3, documentation='\n        A simple boolean annotation of type xsd:boolean\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3659, 2)))

CTD_ANON_3._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'TimestampAnnotation'), CTD_ANON_82, scope=CTD_ANON_3, documentation='\n        A date/time annotation of type xsd:dateTime\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3676, 2)))

CTD_ANON_3._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'TagAnnotation'), CTD_ANON_83, scope=CTD_ANON_3, documentation='\n        A tag annotation (represents a tag or a tagset)\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3693, 2)))

CTD_ANON_3._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'TermAnnotation'), CTD_ANON_84, scope=CTD_ANON_3, documentation='\n        A ontology term annotation\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3710, 2)))

CTD_ANON_3._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'MapAnnotation'), CTD_ANON_69, scope=CTD_ANON_3, documentation='\n        An map annotation. The contents of this is a list of key/value pairs.\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3727, 2)))

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()
    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3420, 6))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(CTD_ANON_3._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'XMLAnnotation')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3421, 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_3._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'FileAnnotation')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3422, 8))
    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_3._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'ListAnnotation')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3423, 8))
    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(CTD_ANON_3._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'LongAnnotation')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3424, 8))
    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(CTD_ANON_3._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'DoubleAnnotation')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3425, 8))
    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_0, False))
    symbol = pyxb.binding.content.ElementUse(CTD_ANON_3._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'CommentAnnotation')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3426, 8))
    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_0, False))
    symbol = pyxb.binding.content.ElementUse(CTD_ANON_3._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'BooleanAnnotation')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3427, 8))
    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_0, False))
    symbol = pyxb.binding.content.ElementUse(CTD_ANON_3._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'TimestampAnnotation')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3428, 8))
    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_0, False))
    symbol = pyxb.binding.content.ElementUse(CTD_ANON_3._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'TagAnnotation')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3429, 8))
    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_0, False))
    symbol = pyxb.binding.content.ElementUse(CTD_ANON_3._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'TermAnnotation')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3430, 8))
    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_0, False))
    symbol = pyxb.binding.content.ElementUse(CTD_ANON_3._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'MapAnnotation')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3431, 8))
    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, 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) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_8, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_9, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_10, [
        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) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_8, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_9, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_10, [
        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) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_8, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_9, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_10, [
        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) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_8, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_9, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_10, [
        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) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_8, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_9, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_10, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_4._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) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_8, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_9, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_10, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_5._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) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_8, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_9, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_10, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_6._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) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_8, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_9, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_10, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_7._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) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_8, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_9, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_10, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_8._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) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_8, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_9, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_10, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_9._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) ]))
    transitions.append(fac.Transition(st_5, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_6, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_7, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_8, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_9, [
        fac.UpdateInstruction(cc_0, True) ]))
    transitions.append(fac.Transition(st_10, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_10._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
CTD_ANON_3._Automaton = _BuildAutomaton_3()




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()
    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3585, 18))
    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('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3585, 18))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.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_4._Automaton = _BuildAutomaton_4()




CTD_ANON_5._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'ShapeGroup'), Shape, abstract=pyxb.binding.datatypes.boolean(1), scope=CTD_ANON_5, location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3795, 2)))

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 = set()
    symbol = pyxb.binding.content.ElementUse(CTD_ANON_5._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'ShapeGroup')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3762, 16))
    st_0 = fac.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_5._Automaton = _BuildAutomaton_5()




CTD_ANON_6._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'BinaryOnly'), CTD_ANON_7, scope=CTD_ANON_6, documentation=' Pointer to an external metadata file. If this\n              element is present, then no other metadata may be present in this\n              file, i.e. this file is a place-holder. ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 79, 10)))

CTD_ANON_6._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'Image'), CTD_ANON_17, scope=CTD_ANON_6, documentation="\n        This element describes the actual image and its meta-data.\n        The elements that are references (ending in Ref or Settings) refer to\n        elements defined outside of the Image element. Ref elements are simple\n        links, while Settings elements are links with additional values.\n\n        If any of the required Image attributes or elements are missing, its\n        guaranteed to be an invalid document. The required attributes and\n        elements are ID and Pixels.\n\n        ExperimenterRef is required for all Images with well formed LSIDs.\n        ImageType is a vendor-specific designation of the type of image this is.\n        Examples of ImageType include 'STK', 'SoftWorx', etc.\n        The Name attributes are in all cases the name of the element\n        instance. In this case, the name of the image, not necessarily the filename.\n        Physical size of pixels are microns[\xb5m].\n      ", location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 209, 2)))

CTD_ANON_6._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'Instrument'), CTD_ANON_21, scope=CTD_ANON_6, documentation="\n        This element describes the instrument used to capture the Image.\n        It is primarily a container for manufacturer's model and catalog\n        numbers for the Microscope, LightSource, Detector, Objective and\n        Filters components.\n        The Objective element contains the additional elements LensNA and Magnification.\n        The Filters element can be composed either of separate excitation,\n        emission filters and a dichroic mirror or a single filter set.\n        Within the Image itself, a reference is made to this one Filter element.\n        There may be multiple light sources, detectors, objectives and filters on a microscope.\n        Each of these has their own ID attribute, which can be referred to from Channel.\n        It is understood that the light path configuration can be different\n        for each channel, but cannot be different for each timepoint or\n        each plane of an XYZ stack.\n      ", location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 979, 2)))

CTD_ANON_6._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'Project'), CTD_ANON_22, scope=CTD_ANON_6, documentation='\n        The Project ID is required.\n        Datasets can be grouped into projects using a many-to-many relationship.\n        A Dataset may belong to one or more Projects by including one or more ProjectRef elements which refer to Project IDs.\n        Projects do not directly contain images - only by virtue of containing datasets, which themselves contain images.\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1101, 2)))

CTD_ANON_6._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'ExperimenterGroup'), CTD_ANON_23, scope=CTD_ANON_6, documentation='\n        The ExperimenterGroupID is required.\n        Information should ideally be specified for at least one Leader as a contact for the group.\n        The Leaders are themselves Experimenters.\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1142, 2)))

CTD_ANON_6._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'Dataset'), CTD_ANON_25, scope=CTD_ANON_6, documentation='\n        An element specifying a collection of images that are always processed together.\n        Images can belong to more than one Dataset, and a Dataset may contain more than one Image.\n        Images contain one or more DatasetRef elements to specify what datasets they belong to.\n        Once a Dataset has been processed in any way, its collection of images cannot be altered.\n        The ExperimenterRef and ExperimenterGroupRef elements specify the person and group this Dataset belongs to.\n        Projects may contain one or more Datasets, and Datasets may belong to one or more Projects.\n        This relationship is specified by listing DatasetRef elements within the Project element.\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1201, 2)))

CTD_ANON_6._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'Experiment'), CTD_ANON_26, scope=CTD_ANON_6, documentation="\n        This element describes the type of experiment.  The required Type attribute must contain one or more entries from the following list:\n        FP FRET Time-lapse 4-D+ Screen Immunocytochemistry FISH Electrophysiology  Ion-Imaging Colocalization PGI/Documentation\n        FRAP Photoablation Optical-Trapping Photoactivation Fluorescence-Lifetime Spectral-Imaging Other\n        FP refers to fluorescent proteins, PGI/Documentation is not a 'data' image.\n        The optional Description element may contain free text to further describe the experiment.\n      ", location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1251, 2)))

CTD_ANON_6._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'Experimenter'), CTD_ANON_27, scope=CTD_ANON_6, documentation='\n        This element describes a person who performed an imaging experiment.\n        This person may also be a user of the OME system, in which case the UserName element contains their login name.\n        Experimenters may belong to one or more groups which are specified using one or more ExperimenterGroupRef elements.\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1320, 2)))

CTD_ANON_6._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'Folder'), CTD_ANON_28, scope=CTD_ANON_6, documentation='\n        An element specifying a possibly heterogeneous collection of data.\n        Folders may contain Folders so that data may be organized within a tree of Folders.\n        Data may be in multiple Folders but a Folder may not be in more than one other Folder.\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1377, 2)))

CTD_ANON_6._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'Rights'), CTD_ANON_2, scope=CTD_ANON_6, documentation='\n        The rights holder of this data and the rights held.\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2794, 2)))

CTD_ANON_6._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'StructuredAnnotations'), CTD_ANON_3, scope=CTD_ANON_6, documentation='\n        An unordered collection of annotation attached to objects in the OME data model.\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3413, 2)))

CTD_ANON_6._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'ROI'), CTD_ANON_52, scope=CTD_ANON_6, documentation="\n        A four dimensional 'Region of Interest'.\n        If they are not used, and the Image has more than one plane,\n        the entire set of planes is assumed to be included in the ROI.\n        Multiple ROIs may be specified.\n      ", location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3746, 2)))

CTD_ANON_6._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'Plate'), CTD_ANON_54, scope=CTD_ANON_6, documentation='\n        This element identifies microtiter plates within a screen.\n        A plate can belong to more than one screen.\n        The Screen(s) that a plate belongs to are specified by the ScreenRef element.\n        The Plate ID and Name attributes are required.\n        The Wells in a plate are numbers from the top-left corner in a grid starting at zero.\n        i.e. The top-left well of a plate is index (0,0)\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4300, 2)))

CTD_ANON_6._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'Screen'), CTD_ANON_57, scope=CTD_ANON_6, documentation="\n        The Screen element is a grouping for Plates.\n        The required attribute is the Screen's Name and ID - both must be unique within the document.\n        The Screen element may contain an ExternalRef attribute that refers to an external database.\n        A description of the screen may be specified in the Description element.\n        Screens may contain overlapping sets of Plates i.e.      Screens and Plates have a many-to-many relationship.\n        Plates contain one or more ScreenRef elements to specify what screens they belong to.\n      ", location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4560, 2)))

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('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 61, 8))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 65, 12))
    counters.add(cc_1)
    cc_2 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 66, 12))
    counters.add(cc_2)
    cc_3 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 67, 12))
    counters.add(cc_3)
    cc_4 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 68, 12))
    counters.add(cc_4)
    cc_5 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 69, 12))
    counters.add(cc_5)
    cc_6 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 70, 12))
    counters.add(cc_6)
    cc_7 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 71, 12))
    counters.add(cc_7)
    cc_8 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 72, 12))
    counters.add(cc_8)
    cc_9 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 73, 12))
    counters.add(cc_9)
    cc_10 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 74, 12))
    counters.add(cc_10)
    cc_11 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 75, 12))
    counters.add(cc_11)
    cc_12 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 76, 12))
    counters.add(cc_12)
    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, 'Rights')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 61, 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_1, False))
    symbol = pyxb.binding.content.ElementUse(CTD_ANON_6._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'Project')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 65, 12))
    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(CTD_ANON_6._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'Dataset')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 66, 12))
    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(CTD_ANON_6._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'Folder')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 67, 12))
    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(CTD_ANON_6._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'Experiment')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 68, 12))
    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(CTD_ANON_6._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'Plate')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 69, 12))
    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(CTD_ANON_6._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'Screen')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 70, 12))
    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(CTD_ANON_6._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'Experimenter')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 71, 12))
    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(CTD_ANON_6._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'ExperimenterGroup')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 72, 12))
    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(CTD_ANON_6._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'Instrument')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 73, 12))
    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(CTD_ANON_6._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'Image')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 74, 12))
    st_10 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_10)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_11, False))
    symbol = pyxb.binding.content.ElementUse(CTD_ANON_6._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'StructuredAnnotations')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 75, 12))
    st_11 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_11)
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_12, False))
    symbol = pyxb.binding.content.ElementUse(CTD_ANON_6._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'ROI')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 76, 12))
    st_12 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_12)
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(CTD_ANON_6._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'BinaryOnly')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 79, 10))
    st_13 = fac.State(symbol, is_initial=True, 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) ]))
    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) ]))
    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) ]))
    transitions.append(fac.Transition(st_12, [
        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) ]))
    transitions.append(fac.Transition(st_12, [
        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) ]))
    transitions.append(fac.Transition(st_12, [
        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) ]))
    transitions.append(fac.Transition(st_12, [
        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) ]))
    transitions.append(fac.Transition(st_12, [
        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) ]))
    transitions.append(fac.Transition(st_12, [
        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) ]))
    transitions.append(fac.Transition(st_12, [
        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) ]))
    transitions.append(fac.Transition(st_12, [
        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) ]))
    transitions.append(fac.Transition(st_12, [
        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) ]))
    transitions.append(fac.Transition(st_12, [
        fac.UpdateInstruction(cc_10, False) ]))
    st_10._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_11, [
        fac.UpdateInstruction(cc_11, True) ]))
    transitions.append(fac.Transition(st_12, [
        fac.UpdateInstruction(cc_11, False) ]))
    st_11._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_12, [
        fac.UpdateInstruction(cc_12, True) ]))
    st_12._set_transitionSet(transitions)
    transitions = []
    st_13._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
CTD_ANON_6._Automaton = _BuildAutomaton_6()




CTD_ANON_8._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'HashSHA1'), Hex40, scope=CTD_ANON_8, location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 496, 10)))

CTD_ANON_8._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'AnnotationRef'), CTD_ANON_51, scope=CTD_ANON_8, documentation='\n        The AnnotationRef element is a reference to an element derived\n        from the CommonAnnotation element.\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3435, 2)))

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()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 488, 8))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 498, 8))
    counters.add(cc_1)
    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, 'HashSHA1')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 496, 10))
    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(CTD_ANON_8._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'AnnotationRef')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 498, 8))
    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)
CTD_ANON_8._Automaton = _BuildAutomaton_7()




CTD_ANON_9._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'UUID'), CTD_ANON_10, scope=CTD_ANON_9, documentation='\n              This must be used when the IFDs are located in another file.\n              Note: It is permissible for this to be self referential.\n            ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 801, 8)))

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()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 801, 8))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(CTD_ANON_9._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'UUID')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 801, 8))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.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_9._Automaton = _BuildAutomaton_8()




CTD_ANON_13._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'Map'), Map, scope=CTD_ANON_13, location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1051, 8)))

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('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1051, 8))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(CTD_ANON_13._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'Map')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1051, 8))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.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_13._Automaton = _BuildAutomaton_9()




CTD_ANON_16._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'External'), CTD_ANON_15, scope=CTD_ANON_16, documentation='Describes a file location.  Can optionally specify a portion of a file using Offset and a ReadLength.\n      If Offset and ReadLength are specified in conjuction with Compression, then they point into the uncompressed file.\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3288, 2)))

CTD_ANON_16._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'BinData'), CTD_ANON_50, scope=CTD_ANON_16, documentation='The contents of this element are base64-encoded.  These are not CDATA sections, just a base64 stream.', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3320, 2)))

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_16._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'External')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3369, 8))
    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_16._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'BinData')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3370, 8))
    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)
CTD_ANON_16._Automaton = _BuildAutomaton_10()




CTD_ANON_17._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'AcquisitionDate'), pyxb.binding.datatypes.dateTime, scope=CTD_ANON_17, documentation="\n              The acquisition date of the Image.\n              The element contains an xsd:dateTime string based on the ISO 8601 format (i.e. 1988-04-07T18:39:09.359)\n\n              YYYY-MM-DDTHH:mm:SS.sssZ\n              Y - Year\n              M - Month\n              D - Day\n              H - Hour\n              m - minutes\n              S - Seconds\n              s - sub-seconds (optional)\n              Z - Zone (optional) +HH:mm or -HH:mm or Z for UTC\n\n              Note: xsd:dataTime supports a very wide date range with unlimited precision. The full date range\n              and precision are not typically supported by platform- and language-specific libraries.\n              Where the supported time precision is less than the precision used by the xsd:dateTime\n              timestamp there will be loss of precision; this will typically occur via direct truncation\n              or (less commonly) rounding.\n\n              The year value can be large and/or negative. Any value covering the current or last century\n              should be correctly processed, but some systems cannot process earlier dates.\n\n              The sub-second value is defined as an unlimited number of digits after the decimal point.\n              In Java a minimum of millisecond precision is guaranteed.\n              In C++ microsecond precision is guaranteed, with nanosecond precision being available on\n              some platforms.\n\n              Time zones are supported, eg '2013-10-24T11:52:33+01:00' for Paris, but in most cases it will\n              be converted to UTC when the timestamp is written.\n            ", location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 232, 8)))

CTD_ANON_17._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'Description'), STD_ANON, scope=CTD_ANON_17, documentation='\n              A description for the image. [plain-text multi-line string]\n            ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 268, 8)))

CTD_ANON_17._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'Pixels'), CTD_ANON_18, scope=CTD_ANON_17, documentation="\n        Pixels is going to be removed in the future, but it is still required.\n\n        This is just notice that the contents of Pixels will be\n        moved up to Image in a future release. This is because there\n        has only been 1 Pixels object in each Image for some time.\n        The concept of multiple Pixels sets for one Image failed to\n        take off. It is therefore redundant.\n\n        The Image will be unreadable if any of the required Pixel attributes are missing.\n\n        The Pixels themselves can be stored within the OME-XML compressed by plane, and encoded\n        in Base64.\n        Or the Pixels may be stored in TIFF format.\n\n        The Pixels element should contain a list of BinData or TiffData, each containing a\n        single plane of pixels. These Pixels elements, when read in document order,\n        must produce a 5-D pixel array of the size specified in this element, and in the\n        dimension order specified by 'DimensionOrder'.\n\n        All of the values in the Pixels object when present should match the same value\n        stored in any associated TIFF format (e.g. SizeX should be the same). Where there\n        is a mismatch our readers will take the value from the TIFF structure as overriding\n        the value in the OME-XML. This is simply a pragmatic decision as it increases the\n        likelihood of reading data from a slightly incorrect file.\n      ", location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 307, 2)))

CTD_ANON_17._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'StageLabel'), CTD_ANON_11, scope=CTD_ANON_17, documentation="\n        The StageLabel is used to specify a name and position for a stage position in the microscope's reference frame.\n      ", location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 871, 2)))

CTD_ANON_17._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'ImagingEnvironment'), CTD_ANON_13, scope=CTD_ANON_17, documentation='\n        This describes the environment that the biological sample was in\n        during the experiment.\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1041, 2)))

CTD_ANON_17._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'MicrobeamManipulationRef'), CTD_ANON_37, scope=CTD_ANON_17, location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2867, 2)))

CTD_ANON_17._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'ExperimentRef'), CTD_ANON_38, scope=CTD_ANON_17, location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2876, 2)))

CTD_ANON_17._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'ExperimenterRef'), CTD_ANON_41, scope=CTD_ANON_17, documentation='\n        This empty element has a required Experimenter ID and an optional DocumentID attribute which refers to one of the Experimenters defined within OME.\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2909, 2)))

CTD_ANON_17._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'ExperimenterGroupRef'), CTD_ANON_42, scope=CTD_ANON_17, documentation='This empty element has a reference (the ExperimenterGroup ID attribute) to a ExperimenterGroup defined within OME.', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2923, 2)))

CTD_ANON_17._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'InstrumentRef'), CTD_ANON_43, scope=CTD_ANON_17, documentation='\n        This empty element can be used (via the required Instrument ID attribute) to refer to an Instrument defined within OME.\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2935, 2)))

CTD_ANON_17._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'ObjectiveSettings'), CTD_ANON_49, scope=CTD_ANON_17, documentation='\n        This holds the setting applied to an objective as well as a\n        reference to the objective.\n        The ID is the objective used in this case.\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3129, 2)))

CTD_ANON_17._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'AnnotationRef'), CTD_ANON_51, scope=CTD_ANON_17, documentation='\n        The AnnotationRef element is a reference to an element derived\n        from the CommonAnnotation element.\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3435, 2)))

CTD_ANON_17._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'ROIRef'), CTD_ANON_53, scope=CTD_ANON_17, location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4247, 2)))

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()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 232, 8))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 267, 8))
    counters.add(cc_1)
    cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 268, 8))
    counters.add(cc_2)
    cc_3 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 280, 8))
    counters.add(cc_3)
    cc_4 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 281, 8))
    counters.add(cc_4)
    cc_5 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 282, 8))
    counters.add(cc_5)
    cc_6 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 283, 8))
    counters.add(cc_6)
    cc_7 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 284, 8))
    counters.add(cc_7)
    cc_8 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 285, 8))
    counters.add(cc_8)
    cc_9 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 287, 8))
    counters.add(cc_9)
    cc_10 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 292, 8))
    counters.add(cc_10)
    cc_11 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 297, 8))
    counters.add(cc_11)
    states = []
    final_update = None
    symbol = pyxb.binding.content.ElementUse(CTD_ANON_17._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'AcquisitionDate')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 232, 8))
    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(CTD_ANON_17._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'ExperimenterRef')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 267, 8))
    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(CTD_ANON_17._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'Description')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 268, 8))
    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(CTD_ANON_17._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'ExperimentRef')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 280, 8))
    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(CTD_ANON_17._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'ExperimenterGroupRef')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 281, 8))
    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(CTD_ANON_17._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'InstrumentRef')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 282, 8))
    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(CTD_ANON_17._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'ObjectiveSettings')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 283, 8))
    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(CTD_ANON_17._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'ImagingEnvironment')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 284, 8))
    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(CTD_ANON_17._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'StageLabel')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 285, 8))
    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(CTD_ANON_17._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'Pixels')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 286, 8))
    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_9, False))
    symbol = pyxb.binding.content.ElementUse(CTD_ANON_17._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'ROIRef')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 287, 8))
    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(CTD_ANON_17._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'MicrobeamManipulationRef')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 292, 8))
    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_11, False))
    symbol = pyxb.binding.content.ElementUse(CTD_ANON_17._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'AnnotationRef')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 297, 8))
    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) ]))
    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_10, [
         ]))
    transitions.append(fac.Transition(st_11, [
         ]))
    transitions.append(fac.Transition(st_12, [
         ]))
    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) ]))
    transitions.append(fac.Transition(st_12, [
        fac.UpdateInstruction(cc_9, False) ]))
    st_10._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_11, [
        fac.UpdateInstruction(cc_10, True) ]))
    transitions.append(fac.Transition(st_12, [
        fac.UpdateInstruction(cc_10, False) ]))
    st_11._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_12, [
        fac.UpdateInstruction(cc_11, True) ]))
    st_12._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
CTD_ANON_17._Automaton = _BuildAutomaton_11()




CTD_ANON_18._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'Plane'), CTD_ANON_8, scope=CTD_ANON_18, documentation='\n        The Plane object holds microscope stage and image timing data\n        for a given channel/z-section/timepoint.\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 478, 2)))

CTD_ANON_18._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'Channel'), CTD_ANON_19, scope=CTD_ANON_18, documentation="\n        There must be one per channel in the Image, even for a single-plane image.\n        And information about how each of them was acquired is stored in the various optional *Ref elements.  Each Logical Channel is composed of one or more\n        ChannelComponents.  For example, an entire spectrum in an FTIR experiment may be stored in a single Logical Channel with each discrete wavenumber of the spectrum\n        constituting a ChannelComponent of the FTIR Logical Channel.  An RGB image where the Red, Green and Blue components do not reflect discrete probes but are\n        instead the output of a color camera would be treated similarly - one Logical channel with three ChannelComponents in this case.\n        The total number of ChannelComponents for a set of pixels must equal SizeC.\n        The IlluminationType attribute is a string enumeration which may be set to 'Transmitted', 'Epifluorescence', 'Oblique', or 'NonLinear'.\n        The user interface logic for labeling a given channel for the user should use the first existing attribute in the following sequence:\n        Name -> Fluor -> EmissionWavelength -> ChannelComponent/Index.\n      ", location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 592, 2)))

CTD_ANON_18._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'MetadataOnly'), pyxb.binding.datatypes.anyType, scope=CTD_ANON_18, documentation='\n        This place holder means there is on pixel data in this file.\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 784, 2)))

CTD_ANON_18._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'TiffData'), CTD_ANON_9, scope=CTD_ANON_18, documentation='\n        This described the location of the pixel data in a tiff file.\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 792, 2)))

CTD_ANON_18._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'BinData'), CTD_ANON_50, scope=CTD_ANON_18, documentation='The contents of this element are base64-encoded.  These are not CDATA sections, just a base64 stream.', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3320, 2)))

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=None, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 339, 8))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 349, 8))
    counters.add(cc_1)
    states = []
    final_update = None
    symbol = pyxb.binding.content.ElementUse(CTD_ANON_18._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'Channel')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 339, 8))
    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_18._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'BinData')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 345, 10))
    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_18._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'TiffData')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 346, 10))
    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(CTD_ANON_18._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'MetadataOnly')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 347, 10))
    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_1, False))
    symbol = pyxb.binding.content.ElementUse(CTD_ANON_18._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'Plane')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 349, 8))
    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, [
         ]))
    transitions.append(fac.Transition(st_4, [
         ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_2, [
         ]))
    transitions.append(fac.Transition(st_4, [
         ]))
    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_1, True) ]))
    st_4._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
CTD_ANON_18._Automaton = _BuildAutomaton_12()




CTD_ANON_19._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'LightPath'), CTD_ANON_, scope=CTD_ANON_19, documentation='A description of the light path', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2411, 2)))

CTD_ANON_19._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'FilterSetRef'), CTD_ANON_46, scope=CTD_ANON_19, location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2981, 2)))

CTD_ANON_19._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'LightSourceSettings'), CTD_ANON_47, scope=CTD_ANON_19, documentation='', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3006, 2)))

CTD_ANON_19._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'DetectorSettings'), CTD_ANON_48, scope=CTD_ANON_19, documentation='\n        This holds the setting applied to a detector as well as a\n        reference to the detector.\n        The ID is the detector used in this case.\n        The values stored in DetectorSettings represent the variable values,\n        fixed values not modified during the acquisition go in Detector.\n\n        Each attribute now has an indication of what type of detector\n        it applies to. This is preparatory work for cleaning up and\n        possibly splitting this object into sub-types.\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3040, 2)))

CTD_ANON_19._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'AnnotationRef'), CTD_ANON_51, scope=CTD_ANON_19, documentation='\n        The AnnotationRef element is a reference to an element derived\n        from the CommonAnnotation element.\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3435, 2)))

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()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 609, 8))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 610, 8))
    counters.add(cc_1)
    cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 611, 8))
    counters.add(cc_2)
    cc_3 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 612, 8))
    counters.add(cc_3)
    cc_4 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 617, 8))
    counters.add(cc_4)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(CTD_ANON_19._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'LightSourceSettings')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 609, 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_1, False))
    symbol = pyxb.binding.content.ElementUse(CTD_ANON_19._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'DetectorSettings')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 610, 8))
    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(CTD_ANON_19._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'FilterSetRef')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 611, 8))
    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(CTD_ANON_19._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'AnnotationRef')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 612, 8))
    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(CTD_ANON_19._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'LightPath')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 617, 8))
    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)
CTD_ANON_19._Automaton = _BuildAutomaton_13()




CTD_ANON_20._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'Description'), STD_ANON_5, scope=CTD_ANON_20, documentation='\n              A description for the Microbeam Manipulation. [plain-text multi-line string]\n            ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 931, 8)))

CTD_ANON_20._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'ExperimenterRef'), CTD_ANON_41, scope=CTD_ANON_20, documentation='\n        This empty element has a required Experimenter ID and an optional DocumentID attribute which refers to one of the Experimenters defined within OME.\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2909, 2)))

CTD_ANON_20._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'LightSourceSettings'), CTD_ANON_47, scope=CTD_ANON_20, documentation='', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3006, 2)))

CTD_ANON_20._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'ROIRef'), CTD_ANON_53, scope=CTD_ANON_20, location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4247, 2)))

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=1, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 931, 8))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 949, 8))
    counters.add(cc_1)
    states = []
    final_update = None
    symbol = pyxb.binding.content.ElementUse(CTD_ANON_20._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'Description')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 931, 8))
    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(CTD_ANON_20._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'ROIRef')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 943, 8))
    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_20._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'ExperimenterRef')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 948, 8))
    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(CTD_ANON_20._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'LightSourceSettings')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 949, 8))
    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_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 = []
    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)
CTD_ANON_20._Automaton = _BuildAutomaton_14()




CTD_ANON_21._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'Microscope'), CTD_ANON_12, scope=CTD_ANON_21, documentation="The microscope's manufacturer specification.", location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1016, 2)))

CTD_ANON_21._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'Objective'), CTD_ANON_29, scope=CTD_ANON_21, documentation="\n        A description of the microscope's objective lens.\n        Required elements include the lens numerical aperture,\n        and the magnification, both of which a floating\n        point (real) numbers.\n        The values are those that are fixed for a particular\n        objective: either because it has been manufactured to\n        this specification or the value has been measured on\n        this particular objective.\n        Correction: This is the type of correction coating applied to this lens.\n        Immersion: This is the types of immersion medium the lens is designed to\n        work with. It is not the same as 'Medium' in ObjectiveRef (a\n        single type) as here Immersion can have compound values like 'Multi'.\n        LensNA: The numerical aperture of the lens (as a float)\n        NominalMagnification: The specified magnification e.g. x10\n        CalibratedMagnification: The measured magnification e.g. x10.3\n        WorkingDistance: WorkingDistance of the lens.\n      ", location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2024, 2)))

CTD_ANON_21._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'Detector'), CTD_ANON_30, scope=CTD_ANON_21, documentation='\n        The type of detector used to capture the image.\n        The Detector ID can be used as a reference within the Channel element in the Image element.\n        The values stored in Detector represent the fixed values,\n        variable values modified during the acquisition go in DetectorSettings\n\n        Each attribute now has an indication of what type of detector\n        it applies to. This is preparatory work for cleaning up and\n        possibly splitting this object into sub-types.\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2144, 2)))

CTD_ANON_21._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'FilterSet'), CTD_ANON_31, scope=CTD_ANON_21, documentation='Filter set manufacturer specification', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2242, 2)))

CTD_ANON_21._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'Filter'), CTD_ANON_32, scope=CTD_ANON_21, documentation="\n        A filter is either an excitation or emission filters.\n        There should be one filter element specified per wavelength in the image.\n        The channel number associated with a filter set is specified in Channel.\n        It is based on the FilterSpec type, so has the required attributes Manufacturer, Model, and LotNumber.\n        It may also contain a Type attribute which may be set to\n        'LongPass', 'ShortPass', 'BandPass', 'MultiPass',\n        'Dichroic', 'NeutralDensity', 'Tuneable' or 'Other'.\n        It can be associated with an optional FilterWheel - Note: this is not the same as a FilterSet\n      ", location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2274, 2)))

CTD_ANON_21._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'Dichroic'), CTD_ANON_33, scope=CTD_ANON_21, documentation='The dichromatic beamsplitter or dichroic mirror used for this filter combination.', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2391, 2)))

CTD_ANON_21._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'LightSourceGroup'), LightSource, abstract=pyxb.binding.datatypes.boolean(1), scope=CTD_ANON_21, location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2454, 2)))

CTD_ANON_21._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'AnnotationRef'), CTD_ANON_51, scope=CTD_ANON_21, documentation='\n        The AnnotationRef element is a reference to an element derived\n        from the CommonAnnotation element.\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3435, 2)))

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()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1000, 8))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1001, 8))
    counters.add(cc_1)
    cc_2 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1002, 8))
    counters.add(cc_2)
    cc_3 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1003, 8))
    counters.add(cc_3)
    cc_4 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1004, 8))
    counters.add(cc_4)
    cc_5 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1005, 8))
    counters.add(cc_5)
    cc_6 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1006, 8))
    counters.add(cc_6)
    cc_7 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1007, 8))
    counters.add(cc_7)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(CTD_ANON_21._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'Microscope')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1000, 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_1, False))
    symbol = pyxb.binding.content.ElementUse(CTD_ANON_21._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'LightSourceGroup')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1001, 8))
    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(CTD_ANON_21._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'Detector')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1002, 8))
    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(CTD_ANON_21._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'Objective')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1003, 8))
    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(CTD_ANON_21._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'FilterSet')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1004, 8))
    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(CTD_ANON_21._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'Filter')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1005, 8))
    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(CTD_ANON_21._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'Dichroic')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1006, 8))
    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(CTD_ANON_21._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'AnnotationRef')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1007, 8))
    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)
CTD_ANON_21._Automaton = _BuildAutomaton_15()




CTD_ANON_22._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'Description'), STD_ANON_8, scope=CTD_ANON_22, documentation='\n              A description for the project. [plain-text multi-line string]\n            ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1113, 8)))

CTD_ANON_22._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'ExperimenterRef'), CTD_ANON_41, scope=CTD_ANON_22, documentation='\n        This empty element has a required Experimenter ID and an optional DocumentID attribute which refers to one of the Experimenters defined within OME.\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2909, 2)))

CTD_ANON_22._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'ExperimenterGroupRef'), CTD_ANON_42, scope=CTD_ANON_22, documentation='This empty element has a reference (the ExperimenterGroup ID attribute) to a ExperimenterGroup defined within OME.', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2923, 2)))

CTD_ANON_22._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'DatasetRef'), CTD_ANON_44, scope=CTD_ANON_22, documentation='\n        The DatasetRef element refers to a Dataset by specifying the Dataset ID attribute.\n        One or more DatasetRef elements may be listed within the Image element to specify what Datasets\n        the Image belongs to.\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2949, 2)))

CTD_ANON_22._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'AnnotationRef'), CTD_ANON_51, scope=CTD_ANON_22, documentation='\n        The AnnotationRef element is a reference to an element derived\n        from the CommonAnnotation element.\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3435, 2)))

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=1, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1113, 8))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1125, 8))
    counters.add(cc_1)
    cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1126, 8))
    counters.add(cc_2)
    cc_3 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1127, 8))
    counters.add(cc_3)
    cc_4 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1132, 8))
    counters.add(cc_4)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(CTD_ANON_22._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'Description')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1113, 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_1, False))
    symbol = pyxb.binding.content.ElementUse(CTD_ANON_22._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'ExperimenterRef')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1125, 8))
    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(CTD_ANON_22._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'ExperimenterGroupRef')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1126, 8))
    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(CTD_ANON_22._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'DatasetRef')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1127, 8))
    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(CTD_ANON_22._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'AnnotationRef')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1132, 8))
    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)
CTD_ANON_22._Automaton = _BuildAutomaton_16()




CTD_ANON_23._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'Description'), STD_ANON_9, scope=CTD_ANON_23, documentation='\n              A description for the group. [plain-text multi-line string]\n            ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1153, 8)))

CTD_ANON_23._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'Leader'), CTD_ANON_24, scope=CTD_ANON_23, documentation='\n        Contact information for a ExperimenterGroup leader specified using a reference\n        to an Experimenter element defined elsewhere in the document.\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1185, 2)))

CTD_ANON_23._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'ExperimenterRef'), CTD_ANON_41, scope=CTD_ANON_23, documentation='\n        This empty element has a required Experimenter ID and an optional DocumentID attribute which refers to one of the Experimenters defined within OME.\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2909, 2)))

CTD_ANON_23._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'AnnotationRef'), CTD_ANON_51, scope=CTD_ANON_23, documentation='\n        The AnnotationRef element is a reference to an element derived\n        from the CommonAnnotation element.\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3435, 2)))

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()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1153, 8))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1165, 8))
    counters.add(cc_1)
    cc_2 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1170, 8))
    counters.add(cc_2)
    cc_3 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1171, 8))
    counters.add(cc_3)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(CTD_ANON_23._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'Description')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1153, 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_1, False))
    symbol = pyxb.binding.content.ElementUse(CTD_ANON_23._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'ExperimenterRef')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1165, 8))
    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(CTD_ANON_23._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'Leader')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1170, 8))
    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(CTD_ANON_23._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'AnnotationRef')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1171, 8))
    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)
CTD_ANON_23._Automaton = _BuildAutomaton_17()




CTD_ANON_25._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'Description'), STD_ANON_10, scope=CTD_ANON_25, documentation='\n              A description for the dataset. [plain-text multi-line string]\n            ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1216, 8)))

CTD_ANON_25._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'ImageRef'), CTD_ANON_36, scope=CTD_ANON_25, documentation='\n        The ImageRef element is a reference to an Image element.\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2844, 2)))

CTD_ANON_25._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'ExperimenterRef'), CTD_ANON_41, scope=CTD_ANON_25, documentation='\n        This empty element has a required Experimenter ID and an optional DocumentID attribute which refers to one of the Experimenters defined within OME.\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2909, 2)))

CTD_ANON_25._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'ExperimenterGroupRef'), CTD_ANON_42, scope=CTD_ANON_25, documentation='This empty element has a reference (the ExperimenterGroup ID attribute) to a ExperimenterGroup defined within OME.', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2923, 2)))

CTD_ANON_25._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'AnnotationRef'), CTD_ANON_51, scope=CTD_ANON_25, documentation='\n        The AnnotationRef element is a reference to an element derived\n        from the CommonAnnotation element.\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3435, 2)))

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()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1216, 8))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1228, 8))
    counters.add(cc_1)
    cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1229, 8))
    counters.add(cc_2)
    cc_3 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1230, 8))
    counters.add(cc_3)
    cc_4 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1235, 8))
    counters.add(cc_4)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(CTD_ANON_25._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'Description')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1216, 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_1, False))
    symbol = pyxb.binding.content.ElementUse(CTD_ANON_25._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'ExperimenterRef')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1228, 8))
    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(CTD_ANON_25._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'ExperimenterGroupRef')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1229, 8))
    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(CTD_ANON_25._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'ImageRef')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1230, 8))
    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(CTD_ANON_25._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'AnnotationRef')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1235, 8))
    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)
CTD_ANON_25._Automaton = _BuildAutomaton_18()




CTD_ANON_26._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'MicrobeamManipulation'), CTD_ANON_20, scope=CTD_ANON_26, documentation='\n        Defines a microbeam operation type and the region of the image it was applied to.\n        The LightSourceRef element is a reference to a LightSource specified in the Instrument element which was used for a technique other than illumination for\n        the purpose of imaging. For example, a laser used for photobleaching.\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 920, 2)))

CTD_ANON_26._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'Description'), STD_ANON_11, scope=CTD_ANON_26, documentation='\n              A description for the experiment. [plain-text multi-line string]\n            ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1264, 8)))

CTD_ANON_26._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'ExperimenterRef'), CTD_ANON_41, scope=CTD_ANON_26, documentation='\n        This empty element has a required Experimenter ID and an optional DocumentID attribute which refers to one of the Experimenters defined within OME.\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2909, 2)))

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()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1264, 8))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1276, 8))
    counters.add(cc_1)
    cc_2 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1283, 8))
    counters.add(cc_2)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(CTD_ANON_26._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'Description')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1264, 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_1, False))
    symbol = pyxb.binding.content.ElementUse(CTD_ANON_26._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'ExperimenterRef')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1276, 8))
    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(CTD_ANON_26._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'MicrobeamManipulation')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1283, 8))
    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)
CTD_ANON_26._Automaton = _BuildAutomaton_19()




CTD_ANON_27._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'AnnotationRef'), CTD_ANON_51, scope=CTD_ANON_27, documentation='\n        The AnnotationRef element is a reference to an element derived\n        from the CommonAnnotation element.\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3435, 2)))

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()
    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1331, 8))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(CTD_ANON_27._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'AnnotationRef')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1331, 8))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.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_27._Automaton = _BuildAutomaton_20()




CTD_ANON_28._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'Description'), STD_ANON_13, scope=CTD_ANON_28, documentation='\n              A description for the folder. [plain-text multi-line string]\n            ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1388, 8)))

CTD_ANON_28._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'ImageRef'), CTD_ANON_36, scope=CTD_ANON_28, documentation='\n        The ImageRef element is a reference to an Image element.\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2844, 2)))

CTD_ANON_28._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'FolderRef'), CTD_ANON_45, scope=CTD_ANON_28, documentation='\n        The FolderRef element refers to a Folder by specifying the Folder ID attribute.\n        One or more FolderRef elements may be listed within the Folder element to specify what Folders\n        the Folder contains. This tree hierarchy must be acyclic.\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2965, 2)))

CTD_ANON_28._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'AnnotationRef'), CTD_ANON_51, scope=CTD_ANON_28, documentation='\n        The AnnotationRef element is a reference to an element derived\n        from the CommonAnnotation element.\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3435, 2)))

CTD_ANON_28._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'ROIRef'), CTD_ANON_53, scope=CTD_ANON_28, location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4247, 2)))

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=1, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1388, 8))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1400, 8))
    counters.add(cc_1)
    cc_2 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1401, 8))
    counters.add(cc_2)
    cc_3 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1406, 8))
    counters.add(cc_3)
    cc_4 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1411, 8))
    counters.add(cc_4)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(CTD_ANON_28._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'Description')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1388, 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_1, False))
    symbol = pyxb.binding.content.ElementUse(CTD_ANON_28._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'FolderRef')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1400, 8))
    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(CTD_ANON_28._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'ImageRef')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1401, 8))
    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(CTD_ANON_28._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'ROIRef')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1406, 8))
    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(CTD_ANON_28._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'AnnotationRef')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1411, 8))
    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)
CTD_ANON_28._Automaton = _BuildAutomaton_21()




CTD_ANON_29._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'AnnotationRef'), CTD_ANON_51, scope=CTD_ANON_29, documentation='\n        The AnnotationRef element is a reference to an element derived\n        from the CommonAnnotation element.\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3435, 2)))

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('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2050, 12))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(CTD_ANON_29._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'AnnotationRef')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2050, 12))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.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_29._Automaton = _BuildAutomaton_22()




CTD_ANON_30._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'AnnotationRef'), CTD_ANON_51, scope=CTD_ANON_30, documentation='\n        The AnnotationRef element is a reference to an element derived\n        from the CommonAnnotation element.\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3435, 2)))

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('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2162, 12))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(CTD_ANON_30._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'AnnotationRef')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2162, 12))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.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_30._Automaton = _BuildAutomaton_23()




CTD_ANON_31._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'ExcitationFilterRef'), FilterRef, scope=CTD_ANON_31, documentation='\n                  The Filters placed in the Excitation light path.\n                ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2251, 12)))

CTD_ANON_31._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'EmissionFilterRef'), FilterRef, scope=CTD_ANON_31, documentation='\n                  The Filters placed in the Emission light path.\n                ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2260, 12)))

CTD_ANON_31._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'DichroicRef'), CTD_ANON_34, scope=CTD_ANON_31, location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2443, 2)))

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('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2251, 12))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2259, 12))
    counters.add(cc_1)
    cc_2 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2260, 12))
    counters.add(cc_2)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(CTD_ANON_31._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'ExcitationFilterRef')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2251, 12))
    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(CTD_ANON_31._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'DichroicRef')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2259, 12))
    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(CTD_ANON_31._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'EmissionFilterRef')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2260, 12))
    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)
CTD_ANON_31._Automaton = _BuildAutomaton_24()




CTD_ANON_32._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'TransmittanceRange'), CTD_ANON_14, scope=CTD_ANON_32, documentation='\n        This records the range of wavelengths that are transmitted by the filter. It also records the maximum amount of light transmitted.\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2325, 2)))

CTD_ANON_32._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'AnnotationRef'), CTD_ANON_51, scope=CTD_ANON_32, documentation='\n        The AnnotationRef element is a reference to an element derived\n        from the CommonAnnotation element.\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3435, 2)))

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()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2292, 12))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2293, 12))
    counters.add(cc_1)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(CTD_ANON_32._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'TransmittanceRange')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2292, 12))
    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(CTD_ANON_32._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'AnnotationRef')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2293, 12))
    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)
CTD_ANON_32._Automaton = _BuildAutomaton_25()




CTD_ANON_33._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'AnnotationRef'), CTD_ANON_51, scope=CTD_ANON_33, documentation='\n        The AnnotationRef element is a reference to an element derived\n        from the CommonAnnotation element.\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3435, 2)))

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()
    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2400, 12))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(CTD_ANON_33._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'AnnotationRef')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2400, 12))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.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_33._Automaton = _BuildAutomaton_26()




LightSource._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'AnnotationRef'), CTD_ANON_51, scope=LightSource, documentation='\n        The AnnotationRef element is a reference to an element derived\n        from the CommonAnnotation element.\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3435, 2)))

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('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2468, 10))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(LightSource._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'AnnotationRef')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2468, 10))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.append(fac.Transition(st_0, [
        fac.UpdateInstruction(cc_0, True) ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
LightSource._Automaton = _BuildAutomaton_27()




Annotation._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'AnnotationRef'), CTD_ANON_51, scope=Annotation, documentation='\n        The AnnotationRef element is a reference to an element derived\n        from the CommonAnnotation element.\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3435, 2)))

Annotation._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'Description'), STD_ANON_28, scope=Annotation, documentation='\n            A description for the annotation. [plain-text multi-line string]\n          ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3460, 6)))

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()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3460, 6))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3473, 8))
    counters.add(cc_1)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(Annotation._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'Description')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3460, 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_1, False))
    symbol = pyxb.binding.content.ElementUse(Annotation._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'AnnotationRef')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3473, 8))
    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)
Annotation._Automaton = _BuildAutomaton_28()




CTD_ANON_52._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'AnnotationRef'), CTD_ANON_51, scope=CTD_ANON_52, documentation='\n        The AnnotationRef element is a reference to an element derived\n        from the CommonAnnotation element.\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3435, 2)))

CTD_ANON_52._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'Union'), CTD_ANON_5, scope=CTD_ANON_52, location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3759, 10)))

CTD_ANON_52._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'Description'), STD_ANON_29, scope=CTD_ANON_52, documentation='\n              A description for the ROI. [plain-text multi-line string]\n            ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3772, 8)))

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()
    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3767, 8))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3772, 8))
    counters.add(cc_1)
    states = []
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(CTD_ANON_52._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'Union')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3759, 10))
    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_52._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'AnnotationRef')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3767, 8))
    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(CTD_ANON_52._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'Description')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3772, 8))
    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)
CTD_ANON_52._Automaton = _BuildAutomaton_29()




Shape._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'AnnotationRef'), CTD_ANON_51, scope=Shape, documentation='\n        The AnnotationRef element is a reference to an element derived\n        from the CommonAnnotation element.\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3435, 2)))

Shape._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'Transform'), AffineTransform, scope=Shape, documentation='\n            This is a matrix used to transform the shape.\n            The element has 6 xsd:float attributes. If the element\n            is present then all 6 values must be included.\n          ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3806, 6)))

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()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3806, 6))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3815, 6))
    counters.add(cc_1)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(Shape._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'Transform')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3806, 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_1, False))
    symbol = pyxb.binding.content.ElementUse(Shape._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'AnnotationRef')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3815, 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, 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)
Shape._Automaton = _BuildAutomaton_30()




CTD_ANON_54._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'AnnotationRef'), CTD_ANON_51, scope=CTD_ANON_54, documentation='\n        The AnnotationRef element is a reference to an element derived\n        from the CommonAnnotation element.\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3435, 2)))

CTD_ANON_54._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'Description'), STD_ANON_33, scope=CTD_ANON_54, documentation='\n              A description for the plate.\n            ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4314, 8)))

CTD_ANON_54._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'PlateAcquisition'), CTD_ANON_59, scope=CTD_ANON_54, documentation='\n        PlateAcquisition is used to describe a single acquisition run for a plate.\n        This object is used to record the set of images acquired in a single\n        acquisition run. The Images for this run are linked to PlateAcquisition\n        through WellSample.\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4660, 2)))

CTD_ANON_54._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'Well'), CTD_ANON_60, scope=CTD_ANON_54, documentation='\n        A Well is a component of the Well/Plate/Screen construct to describe screening applications.\n        A Well has a number of WellSample elements that link to the Images collected in this well.\n        The ReagentRef links any Reagents that were used in this Well. A well is part of only one Plate.\n        The origin for the row and column identifiers is the top left corner of the plate starting at zero.\n        i.e The top left well of a plate is index (0,0)\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4726, 2)))

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()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4314, 8))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4326, 8))
    counters.add(cc_1)
    cc_2 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4327, 8))
    counters.add(cc_2)
    cc_3 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4332, 8))
    counters.add(cc_3)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(CTD_ANON_54._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'Description')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4314, 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_1, False))
    symbol = pyxb.binding.content.ElementUse(CTD_ANON_54._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'Well')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4326, 8))
    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(CTD_ANON_54._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'AnnotationRef')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4327, 8))
    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(CTD_ANON_54._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'PlateAcquisition')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4332, 8))
    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)
CTD_ANON_54._Automaton = _BuildAutomaton_31()




CTD_ANON_55._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'AnnotationRef'), CTD_ANON_51, scope=CTD_ANON_55, documentation='\n        The AnnotationRef element is a reference to an element derived\n        from the CommonAnnotation element.\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3435, 2)))

CTD_ANON_55._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'Description'), STD_ANON_34, scope=CTD_ANON_55, documentation='\n              A long description for the reagent.\n            ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4507, 8)))

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=1, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4507, 8))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4519, 8))
    counters.add(cc_1)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(CTD_ANON_55._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'Description')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4507, 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_1, False))
    symbol = pyxb.binding.content.ElementUse(CTD_ANON_55._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'AnnotationRef')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4519, 8))
    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)
CTD_ANON_55._Automaton = _BuildAutomaton_32()




CTD_ANON_57._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'AnnotationRef'), CTD_ANON_51, scope=CTD_ANON_57, documentation='\n        The AnnotationRef element is a reference to an element derived\n        from the CommonAnnotation element.\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3435, 2)))

CTD_ANON_57._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'Reagent'), CTD_ANON_55, scope=CTD_ANON_57, documentation='\n        Reagent is used to describe a chemical or some other physical experimental parameter.\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4498, 2)))

CTD_ANON_57._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'Description'), STD_ANON_35, scope=CTD_ANON_57, documentation='\n              A description for the screen.\n            ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4574, 8)))

CTD_ANON_57._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'PlateRef'), CTD_ANON_58, scope=CTD_ANON_57, documentation='\n              The PlateRef element is a reference to a Plate element.\n              Screen elements may have one or more PlateRef elements to define the plates that are part of the screen.\n              Plates may belong to more than one screen.\n            ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4587, 8)))

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()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4574, 8))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4586, 8))
    counters.add(cc_1)
    cc_2 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4587, 8))
    counters.add(cc_2)
    cc_3 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4604, 8))
    counters.add(cc_3)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(CTD_ANON_57._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'Description')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4574, 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_1, False))
    symbol = pyxb.binding.content.ElementUse(CTD_ANON_57._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'Reagent')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4586, 8))
    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(CTD_ANON_57._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'PlateRef')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4587, 8))
    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(CTD_ANON_57._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'AnnotationRef')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4604, 8))
    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)
CTD_ANON_57._Automaton = _BuildAutomaton_33()




CTD_ANON_59._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'AnnotationRef'), CTD_ANON_51, scope=CTD_ANON_59, documentation='\n        The AnnotationRef element is a reference to an element derived\n        from the CommonAnnotation element.\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3435, 2)))

CTD_ANON_59._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'Description'), STD_ANON_36, scope=CTD_ANON_59, documentation='\n              A description for the PlateAcquisition.\n            ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4672, 8)))

CTD_ANON_59._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'WellSampleRef'), CTD_ANON_62, scope=CTD_ANON_59, documentation='\n        The WellSampleRef element is a reference to a WellSample element.\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4883, 2)))

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()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4672, 8))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4684, 8))
    counters.add(cc_1)
    cc_2 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4685, 8))
    counters.add(cc_2)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(CTD_ANON_59._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'Description')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4672, 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_1, False))
    symbol = pyxb.binding.content.ElementUse(CTD_ANON_59._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'WellSampleRef')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4684, 8))
    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(CTD_ANON_59._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'AnnotationRef')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4685, 8))
    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)
CTD_ANON_59._Automaton = _BuildAutomaton_34()




CTD_ANON_60._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'AnnotationRef'), CTD_ANON_51, scope=CTD_ANON_60, documentation='\n        The AnnotationRef element is a reference to an element derived\n        from the CommonAnnotation element.\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3435, 2)))

CTD_ANON_60._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'ReagentRef'), CTD_ANON_56, scope=CTD_ANON_60, location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4544, 2)))

CTD_ANON_60._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'WellSample'), CTD_ANON_61, scope=CTD_ANON_60, documentation='\n        WellSample is an individual image that has been captured within a Well.\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4810, 2)))

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()
    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4739, 8))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4744, 8))
    counters.add(cc_1)
    cc_2 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4745, 8))
    counters.add(cc_2)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(CTD_ANON_60._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'WellSample')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4739, 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_1, False))
    symbol = pyxb.binding.content.ElementUse(CTD_ANON_60._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'ReagentRef')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4744, 8))
    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(CTD_ANON_60._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'AnnotationRef')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4745, 8))
    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)
CTD_ANON_60._Automaton = _BuildAutomaton_35()




CTD_ANON_61._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'ImageRef'), CTD_ANON_36, scope=CTD_ANON_61, documentation='\n        The ImageRef element is a reference to an Image element.\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2844, 2)))

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=0, max=1, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4819, 8))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(CTD_ANON_61._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'ImageRef')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4819, 8))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.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_61._Automaton = _BuildAutomaton_36()




CTD_ANON_63._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'Pump'), CTD_ANON_35, scope=CTD_ANON_63, documentation="\n        The Pump element is a reference to a LightSource.  It is used within the Laser element to specify the light source for the laser's pump (if any).\n      ", location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2778, 2)))

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('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2468, 10))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2508, 12))
    counters.add(cc_1)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(CTD_ANON_63._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'AnnotationRef')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2468, 10))
    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(CTD_ANON_63._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'Pump')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2508, 12))
    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)
CTD_ANON_63._Automaton = _BuildAutomaton_37()




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('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2468, 10))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(CTD_ANON_64._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'AnnotationRef')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2468, 10))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.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_64._Automaton = _BuildAutomaton_38()




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()
    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2468, 10))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(CTD_ANON_65._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'AnnotationRef')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2468, 10))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.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_65._Automaton = _BuildAutomaton_39()




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('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2468, 10))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(CTD_ANON_66._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'AnnotationRef')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2468, 10))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    transitions.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_66._Automaton = _BuildAutomaton_40()




CTD_ANON_67._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'Map'), Map, scope=CTD_ANON_67, location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2772, 12)))

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()
    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2468, 10))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2772, 12))
    counters.add(cc_1)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(CTD_ANON_67._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'AnnotationRef')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2468, 10))
    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(CTD_ANON_67._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'Map')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2772, 12))
    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)
CTD_ANON_67._Automaton = _BuildAutomaton_41()




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()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3460, 6))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3473, 8))
    counters.add(cc_1)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(BasicAnnotation._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'Description')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3460, 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_1, False))
    symbol = pyxb.binding.content.ElementUse(BasicAnnotation._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'AnnotationRef')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3473, 8))
    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)
BasicAnnotation._Automaton = _BuildAutomaton_42()




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()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3460, 6))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3473, 8))
    counters.add(cc_1)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(TextAnnotation._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'Description')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3460, 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_1, False))
    symbol = pyxb.binding.content.ElementUse(TextAnnotation._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'AnnotationRef')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3473, 8))
    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)
TextAnnotation._Automaton = _BuildAutomaton_43()




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()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3460, 6))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3473, 8))
    counters.add(cc_1)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(TypeAnnotation._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'Description')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3460, 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_1, False))
    symbol = pyxb.binding.content.ElementUse(TypeAnnotation._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'AnnotationRef')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3473, 8))
    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)
TypeAnnotation._Automaton = _BuildAutomaton_44()




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()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3460, 6))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3473, 8))
    counters.add(cc_1)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(CTD_ANON_68._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'Description')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3460, 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_1, False))
    symbol = pyxb.binding.content.ElementUse(CTD_ANON_68._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'AnnotationRef')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3473, 8))
    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)
CTD_ANON_68._Automaton = _BuildAutomaton_45()




CTD_ANON_69._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'Value'), Map, scope=CTD_ANON_69, location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3738, 12)))

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()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3460, 6))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3473, 8))
    counters.add(cc_1)
    states = []
    final_update = None
    symbol = pyxb.binding.content.ElementUse(CTD_ANON_69._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'Description')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3460, 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(CTD_ANON_69._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'AnnotationRef')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3473, 8))
    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_69._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'Value')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3738, 12))
    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 = []
    st_2._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
CTD_ANON_69._Automaton = _BuildAutomaton_46()




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()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3806, 6))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3815, 6))
    counters.add(cc_1)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(CTD_ANON_70._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'Transform')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3806, 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_1, False))
    symbol = pyxb.binding.content.ElementUse(CTD_ANON_70._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'AnnotationRef')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3815, 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, 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)
CTD_ANON_70._Automaton = _BuildAutomaton_47()




CTD_ANON_71._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'BinData'), CTD_ANON_50, scope=CTD_ANON_71, documentation='The contents of this element are base64-encoded.  These are not CDATA sections, just a base64 stream.', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3320, 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=1, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3806, 6))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3815, 6))
    counters.add(cc_1)
    states = []
    final_update = None
    symbol = pyxb.binding.content.ElementUse(CTD_ANON_71._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'Transform')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3806, 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(CTD_ANON_71._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'AnnotationRef')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3815, 6))
    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_71._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'BinData')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4023, 12))
    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 = []
    st_2._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
CTD_ANON_71._Automaton = _BuildAutomaton_48()




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('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3806, 6))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3815, 6))
    counters.add(cc_1)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(CTD_ANON_72._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'Transform')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3806, 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_1, False))
    symbol = pyxb.binding.content.ElementUse(CTD_ANON_72._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'AnnotationRef')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3815, 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, 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)
CTD_ANON_72._Automaton = _BuildAutomaton_49()




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()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3806, 6))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3815, 6))
    counters.add(cc_1)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(CTD_ANON_73._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'Transform')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3806, 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_1, False))
    symbol = pyxb.binding.content.ElementUse(CTD_ANON_73._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'AnnotationRef')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3815, 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, 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)
CTD_ANON_73._Automaton = _BuildAutomaton_50()




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()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3806, 6))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3815, 6))
    counters.add(cc_1)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(CTD_ANON_74._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'Transform')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3806, 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_1, False))
    symbol = pyxb.binding.content.ElementUse(CTD_ANON_74._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'AnnotationRef')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3815, 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, 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)
CTD_ANON_74._Automaton = _BuildAutomaton_51()




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()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3806, 6))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3815, 6))
    counters.add(cc_1)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(CTD_ANON_75._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'Transform')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3806, 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_1, False))
    symbol = pyxb.binding.content.ElementUse(CTD_ANON_75._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'AnnotationRef')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3815, 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, 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)
CTD_ANON_75._Automaton = _BuildAutomaton_52()




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()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3806, 6))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3815, 6))
    counters.add(cc_1)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(CTD_ANON_76._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'Transform')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3806, 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_1, False))
    symbol = pyxb.binding.content.ElementUse(CTD_ANON_76._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'AnnotationRef')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3815, 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, 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)
CTD_ANON_76._Automaton = _BuildAutomaton_53()




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()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3806, 6))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3815, 6))
    counters.add(cc_1)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(CTD_ANON_77._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'Transform')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3806, 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_1, False))
    symbol = pyxb.binding.content.ElementUse(CTD_ANON_77._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'AnnotationRef')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3815, 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, 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)
CTD_ANON_77._Automaton = _BuildAutomaton_54()




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('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3460, 6))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3473, 8))
    counters.add(cc_1)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(NumericAnnotation._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'Description')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3460, 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_1, False))
    symbol = pyxb.binding.content.ElementUse(NumericAnnotation._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'AnnotationRef')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3473, 8))
    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)
NumericAnnotation._Automaton = _BuildAutomaton_55()




CTD_ANON_78._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'BinaryFile'), CTD_ANON_16, scope=CTD_ANON_78, documentation='Describes a binary file.', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3362, 2)))

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('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3460, 6))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3473, 8))
    counters.add(cc_1)
    states = []
    final_update = None
    symbol = pyxb.binding.content.ElementUse(CTD_ANON_78._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'Description')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3460, 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(CTD_ANON_78._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'AnnotationRef')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3473, 8))
    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_78._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'BinaryFile')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3565, 12))
    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 = []
    st_2._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
CTD_ANON_78._Automaton = _BuildAutomaton_56()




CTD_ANON_79._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'Value'), CTD_ANON_4, scope=CTD_ANON_79, location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3582, 12)))

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=1, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3460, 6))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3473, 8))
    counters.add(cc_1)
    states = []
    final_update = None
    symbol = pyxb.binding.content.ElementUse(CTD_ANON_79._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'Description')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3460, 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(CTD_ANON_79._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'AnnotationRef')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3473, 8))
    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_79._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'Value')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3582, 12))
    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 = []
    st_2._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
CTD_ANON_79._Automaton = _BuildAutomaton_57()




CTD_ANON_80._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'Value'), pyxb.binding.datatypes.string, scope=CTD_ANON_80, location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3619, 12)))

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=1, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3460, 6))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3473, 8))
    counters.add(cc_1)
    states = []
    final_update = None
    symbol = pyxb.binding.content.ElementUse(CTD_ANON_80._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'Description')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3460, 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(CTD_ANON_80._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'AnnotationRef')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3473, 8))
    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_80._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'Value')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3619, 12))
    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 = []
    st_2._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
CTD_ANON_80._Automaton = _BuildAutomaton_58()




CTD_ANON_81._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'Value'), pyxb.binding.datatypes.boolean, scope=CTD_ANON_81, location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3670, 12)))

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('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3460, 6))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3473, 8))
    counters.add(cc_1)
    states = []
    final_update = None
    symbol = pyxb.binding.content.ElementUse(CTD_ANON_81._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'Description')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3460, 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(CTD_ANON_81._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'AnnotationRef')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3473, 8))
    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_81._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'Value')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3670, 12))
    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 = []
    st_2._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
CTD_ANON_81._Automaton = _BuildAutomaton_59()




CTD_ANON_82._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'Value'), pyxb.binding.datatypes.dateTime, scope=CTD_ANON_82, location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3687, 12)))

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('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3460, 6))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3473, 8))
    counters.add(cc_1)
    states = []
    final_update = None
    symbol = pyxb.binding.content.ElementUse(CTD_ANON_82._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'Description')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3460, 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(CTD_ANON_82._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'AnnotationRef')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3473, 8))
    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_82._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'Value')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3687, 12))
    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 = []
    st_2._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
CTD_ANON_82._Automaton = _BuildAutomaton_60()




CTD_ANON_83._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'Value'), pyxb.binding.datatypes.string, scope=CTD_ANON_83, location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3704, 12)))

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=1, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3460, 6))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3473, 8))
    counters.add(cc_1)
    states = []
    final_update = None
    symbol = pyxb.binding.content.ElementUse(CTD_ANON_83._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'Description')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3460, 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(CTD_ANON_83._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'AnnotationRef')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3473, 8))
    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_83._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'Value')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3704, 12))
    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 = []
    st_2._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
CTD_ANON_83._Automaton = _BuildAutomaton_61()




CTD_ANON_84._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'Value'), pyxb.binding.datatypes.string, scope=CTD_ANON_84, location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3721, 12)))

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()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3460, 6))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3473, 8))
    counters.add(cc_1)
    states = []
    final_update = None
    symbol = pyxb.binding.content.ElementUse(CTD_ANON_84._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'Description')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3460, 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(CTD_ANON_84._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'AnnotationRef')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3473, 8))
    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_84._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'Value')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3721, 12))
    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 = []
    st_2._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
CTD_ANON_84._Automaton = _BuildAutomaton_62()




CTD_ANON_85._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'Value'), pyxb.binding.datatypes.long, scope=CTD_ANON_85, location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3636, 12)))

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('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3460, 6))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3473, 8))
    counters.add(cc_1)
    states = []
    final_update = None
    symbol = pyxb.binding.content.ElementUse(CTD_ANON_85._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'Description')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3460, 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(CTD_ANON_85._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'AnnotationRef')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3473, 8))
    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_85._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'Value')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3636, 12))
    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 = []
    st_2._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
CTD_ANON_85._Automaton = _BuildAutomaton_63()




CTD_ANON_86._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'Value'), pyxb.binding.datatypes.double, scope=CTD_ANON_86, location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3653, 12)))

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=1, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3460, 6))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3473, 8))
    counters.add(cc_1)
    states = []
    final_update = None
    symbol = pyxb.binding.content.ElementUse(CTD_ANON_86._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'Description')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3460, 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(CTD_ANON_86._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'AnnotationRef')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3473, 8))
    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_86._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'Value')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3653, 12))
    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 = []
    st_2._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
CTD_ANON_86._Automaton = _BuildAutomaton_64()


Laser._setSubstitutionGroup(LightSourceGroup)

Arc._setSubstitutionGroup(LightSourceGroup)

Filament._setSubstitutionGroup(LightSourceGroup)

LightEmittingDiode._setSubstitutionGroup(LightSourceGroup)

GenericExcitationSource._setSubstitutionGroup(LightSourceGroup)

Rectangle._setSubstitutionGroup(ShapeGroup)

Mask._setSubstitutionGroup(ShapeGroup)

Point._setSubstitutionGroup(ShapeGroup)

Ellipse._setSubstitutionGroup(ShapeGroup)

Line._setSubstitutionGroup(ShapeGroup)

Polyline._setSubstitutionGroup(ShapeGroup)

Polygon._setSubstitutionGroup(ShapeGroup)

Label._setSubstitutionGroup(ShapeGroup)