################################################## 
# SessionCreateRQService_services_types.py 
# generated by ZSI.generate.wsdl2python
##################################################


import ZSI
import ZSI.TCcompound
from ZSI.TC import ElementDeclaration,TypeDefinition
from ZSI.generate.pyclass import pyclass_type

##############################
# targetNamespace
# http://schemas.xmlsoap.org/ws/2002/12/secext
##############################

class ns10:
    targetNamespace = "http://schemas.xmlsoap.org/ws/2002/12/secext"

    class Security_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration):
        schema = "http://schemas.xmlsoap.org/ws/2002/12/secext"
        literal = "Security"
        def __init__(self, **kw):
            ns = ns10.Security_Dec.schema
            TClist = [self.__class__.UsernameToken_Dec(minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"BinarySecurityToken"), aname="_BinarySecurityToken", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded"))]
            kw["pname"] = ("http://schemas.xmlsoap.org/ws/2002/12/secext","Security")
            kw["aname"] = "_Security"
            self.attribute_typecode_dict = {}
            ZSI.TCcompound.ComplexType.__init__(self, None, TClist, inorder=0, **kw)
            class Holder:
                __metaclass__ = pyclass_type
                typecode = self
                def __init__(self):
                    # pyclass
                    self._UsernameToken = None
                    self._BinarySecurityToken = None
                    return
            Holder.__name__ = "Security_Holder"
            self.pyclass = Holder


        class UsernameToken_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration):
            schema = "http://schemas.xmlsoap.org/ws/2002/12/secext"
            literal = "UsernameToken"
            def __init__(self, **kw):
                ns = ns10.Security_Dec.UsernameToken_Dec.schema
                TClist = [ZSI.TC.String(pname=(ns,"Username"), aname="_Username", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"Password"), aname="_Password", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ZSI.TC.String(pname="Organization", aname="_Organization", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ZSI.TC.String(pname="Domain", aname="_Domain", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded"))]
                kw["pname"] = ("http://schemas.xmlsoap.org/ws/2002/12/secext","UsernameToken")
                kw["aname"] = "_UsernameToken"
                self.attribute_typecode_dict = {}
                ZSI.TCcompound.ComplexType.__init__(self, None, TClist, inorder=0, **kw)
                class Holder:
                    __metaclass__ = pyclass_type
                    typecode = self
                    def __init__(self):
                        # pyclass
                        self._Username = None
                        self._Password = None
                        self._Organization = None
                        self._Domain = None
                        return
                Holder.__name__ = "UsernameToken_Holder"
                self.pyclass = Holder




# end class ns10 (tns: http://schemas.xmlsoap.org/ws/2002/12/secext)

##############################
# targetNamespace
# http://www.w3.org/2000/09/xmldsig#
##############################

class ns6:
    targetNamespace = "http://www.w3.org/2000/09/xmldsig#"

    class CryptoBinary_Def(ZSI.TC.Base64String, TypeDefinition):
        schema = "http://www.w3.org/2000/09/xmldsig#"
        type = (schema, "CryptoBinary")
        def __init__(self, pname, **kw):
            ZSI.TC.Base64String.__init__(self, pname, pyclass=None, **kw)
            class Holder(str):
                typecode = self
            self.pyclass = Holder

    class SignatureType_Def(ZSI.TCcompound.ComplexType, TypeDefinition):
        schema = "http://www.w3.org/2000/09/xmldsig#"
        type = (schema, "SignatureType")
        def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw):
            ns = ns6.SignatureType_Def.schema
            TClist = [ns6.SignedInfo_Dec(minOccurs=1, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ns6.SignatureValue_Dec(minOccurs=1, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ns6.KeyInfo_Dec(minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ns6.Object_Dec(minOccurs=0, maxOccurs="unbounded", nillable=False, encoded=kw.get("encoded"))]
            self.attribute_typecode_dict = attributes or {}
            if extend: TClist += ofwhat
            if restrict: TClist = ofwhat
            else:
                # attribute handling code
                self.attribute_typecode_dict["Id"] = ZSI.TC.AnyType()
            ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw)
            class Holder:
                __metaclass__ = pyclass_type
                typecode = self
                def __init__(self):
                    # pyclass
                    self._SignedInfo = None
                    self._SignatureValue = None
                    self._KeyInfo = None
                    self._Object = None
                    return
            Holder.__name__ = "SignatureType_Holder"
            self.pyclass = Holder

    class SignatureValueType_Def(ZSI.TC.Base64String, TypeDefinition):
        # ComplexType/SimpleContent derivation of built-in type
        schema = "http://www.w3.org/2000/09/xmldsig#"
        type = (schema, "SignatureValueType")
        def __init__(self, pname, **kw):
            if getattr(self, "attribute_typecode_dict", None) is None: self.attribute_typecode_dict = {}
            # attribute handling code
            self.attribute_typecode_dict["Id"] = ZSI.TC.AnyType()
            ZSI.TC.Base64String.__init__(self, pname, **kw)
            class Holder(str):
                __metaclass__ = pyclass_type
                typecode = self
            self.pyclass = Holder

    class SignedInfoType_Def(ZSI.TCcompound.ComplexType, TypeDefinition):
        schema = "http://www.w3.org/2000/09/xmldsig#"
        type = (schema, "SignedInfoType")
        def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw):
            ns = ns6.SignedInfoType_Def.schema
            TClist = [ns6.CanonicalizationMethod_Dec(minOccurs=1, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ns6.SignatureMethod_Dec(minOccurs=1, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ns6.Reference_Dec(minOccurs=1, maxOccurs="unbounded", nillable=False, encoded=kw.get("encoded"))]
            self.attribute_typecode_dict = attributes or {}
            if extend: TClist += ofwhat
            if restrict: TClist = ofwhat
            else:
                # attribute handling code
                self.attribute_typecode_dict["Id"] = ZSI.TC.AnyType()
            ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw)
            class Holder:
                __metaclass__ = pyclass_type
                typecode = self
                def __init__(self):
                    # pyclass
                    self._CanonicalizationMethod = None
                    self._SignatureMethod = None
                    self._Reference = None
                    return
            Holder.__name__ = "SignedInfoType_Holder"
            self.pyclass = Holder

    class CanonicalizationMethodType_Def(ZSI.TCcompound.ComplexType, TypeDefinition):
        schema = "http://www.w3.org/2000/09/xmldsig#"
        type = (schema, "CanonicalizationMethodType")
        def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw):
            ns = ns6.CanonicalizationMethodType_Def.schema
            TClist = [ZSI.TC.AnyElement(aname="_any", minOccurs=0, maxOccurs="unbounded", nillable=False, processContents="strict")]
            self.attribute_typecode_dict = attributes or {}
            if extend: TClist += ofwhat
            if restrict: TClist = ofwhat
            else:
                # attribute handling code
                self.attribute_typecode_dict["Algorithm"] = ZSI.TC.URI()
            ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, mixed=True, mixed_aname="_text", **kw)
            class Holder:
                __metaclass__ = pyclass_type
                typecode = self
                def __init__(self):
                    # pyclass
                    self._None = []
                    return
            Holder.__name__ = "CanonicalizationMethodType_Holder"
            self.pyclass = Holder

    class SignatureMethodType_Def(ZSI.TCcompound.ComplexType, TypeDefinition):
        schema = "http://www.w3.org/2000/09/xmldsig#"
        type = (schema, "SignatureMethodType")
        def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw):
            ns = ns6.SignatureMethodType_Def.schema
            TClist = [ns6.HMACOutputLengthType_Def(pname=(ns,"HMACOutputLength"), aname="_HMACOutputLength", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ZSI.TC.AnyElement(aname="_any", minOccurs=0, maxOccurs="unbounded", nillable=False, processContents="strict")]
            self.attribute_typecode_dict = attributes or {}
            if extend: TClist += ofwhat
            if restrict: TClist = ofwhat
            else:
                # attribute handling code
                self.attribute_typecode_dict["Algorithm"] = ZSI.TC.URI()
            ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, mixed=True, mixed_aname="_text", **kw)
            class Holder:
                __metaclass__ = pyclass_type
                typecode = self
                def __init__(self):
                    # pyclass
                    self._HMACOutputLength = None
                    self._None = []
                    return
            Holder.__name__ = "SignatureMethodType_Holder"
            self.pyclass = Holder

    class ReferenceType_Def(ZSI.TCcompound.ComplexType, TypeDefinition):
        schema = "http://www.w3.org/2000/09/xmldsig#"
        type = (schema, "ReferenceType")
        def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw):
            ns = ns6.ReferenceType_Def.schema
            TClist = [ns6.Transforms_Dec(minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ns6.DigestMethod_Dec(minOccurs=1, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ns6.DigestValue_Dec(minOccurs=1, maxOccurs=1, nillable=False, encoded=kw.get("encoded"))]
            self.attribute_typecode_dict = attributes or {}
            if extend: TClist += ofwhat
            if restrict: TClist = ofwhat
            else:
                # attribute handling code
                self.attribute_typecode_dict["Id"] = ZSI.TC.AnyType()
                self.attribute_typecode_dict["URI"] = ZSI.TC.URI()
                self.attribute_typecode_dict["Type"] = ZSI.TC.URI()
            ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw)
            class Holder:
                __metaclass__ = pyclass_type
                typecode = self
                def __init__(self):
                    # pyclass
                    self._Transforms = None
                    self._DigestMethod = None
                    self._DigestValue = None
                    return
            Holder.__name__ = "ReferenceType_Holder"
            self.pyclass = Holder

    class TransformsType_Def(ZSI.TCcompound.ComplexType, TypeDefinition):
        schema = "http://www.w3.org/2000/09/xmldsig#"
        type = (schema, "TransformsType")
        def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw):
            ns = ns6.TransformsType_Def.schema
            TClist = [ns6.Transform_Dec(minOccurs=1, maxOccurs="unbounded", nillable=False, encoded=kw.get("encoded"))]
            self.attribute_typecode_dict = attributes or {}
            if extend: TClist += ofwhat
            if restrict: TClist = ofwhat
            ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw)
            class Holder:
                __metaclass__ = pyclass_type
                typecode = self
                def __init__(self):
                    # pyclass
                    self._Transform = None
                    return
            Holder.__name__ = "TransformsType_Holder"
            self.pyclass = Holder

    class TransformType_Def(ZSI.TCcompound.ComplexType, TypeDefinition):
        schema = "http://www.w3.org/2000/09/xmldsig#"
        type = (schema, "TransformType")
        def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw):
            ns = ns6.TransformType_Def.schema
            TClist = [ZSI.TC.AnyElement(aname="_any", minOccurs=0, maxOccurs="unbounded", nillable=False, processContents="lax"), ZSI.TC.String(pname=(ns,"XPath"), aname="_XPath", minOccurs=0, maxOccurs="unbounded", nillable=False, encoded=kw.get("encoded"))]
            self.attribute_typecode_dict = attributes or {}
            if extend: TClist += ofwhat
            if restrict: TClist = ofwhat
            else:
                # attribute handling code
                self.attribute_typecode_dict["Algorithm"] = ZSI.TC.URI()
            ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, mixed=True, mixed_aname="_text", **kw)
            class Holder:
                __metaclass__ = pyclass_type
                typecode = self
                def __init__(self):
                    # pyclass
                    self._None = []
                    self._XPath = []
                    return
            Holder.__name__ = "TransformType_Holder"
            self.pyclass = Holder

    class DigestMethodType_Def(ZSI.TCcompound.ComplexType, TypeDefinition):
        schema = "http://www.w3.org/2000/09/xmldsig#"
        type = (schema, "DigestMethodType")
        def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw):
            ns = ns6.DigestMethodType_Def.schema
            TClist = [ZSI.TC.AnyElement(aname="_any", minOccurs=0, maxOccurs="unbounded", nillable=False, processContents="lax")]
            self.attribute_typecode_dict = attributes or {}
            if extend: TClist += ofwhat
            if restrict: TClist = ofwhat
            else:
                # attribute handling code
                self.attribute_typecode_dict["Algorithm"] = ZSI.TC.URI()
            ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, mixed=True, mixed_aname="_text", **kw)
            class Holder:
                __metaclass__ = pyclass_type
                typecode = self
                def __init__(self):
                    # pyclass
                    self._None = []
                    return
            Holder.__name__ = "DigestMethodType_Holder"
            self.pyclass = Holder

    class DigestValueType_Def(ZSI.TC.Base64String, TypeDefinition):
        schema = "http://www.w3.org/2000/09/xmldsig#"
        type = (schema, "DigestValueType")
        def __init__(self, pname, **kw):
            ZSI.TC.Base64String.__init__(self, pname, pyclass=None, **kw)
            class Holder(str):
                typecode = self
            self.pyclass = Holder

    class KeyInfoType_Def(ZSI.TCcompound.ComplexType, TypeDefinition):
        schema = "http://www.w3.org/2000/09/xmldsig#"
        type = (schema, "KeyInfoType")
        def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw):
            ns = ns6.KeyInfoType_Def.schema
            TClist = [ns6.KeyName_Dec(minOccurs=0, maxOccurs="unbounded", nillable=False, encoded=kw.get("encoded")), ns6.KeyValue_Dec(minOccurs=0, maxOccurs="unbounded", nillable=False, encoded=kw.get("encoded")), ns6.RetrievalMethod_Dec(minOccurs=0, maxOccurs="unbounded", nillable=False, encoded=kw.get("encoded")), ns6.X509Data_Dec(minOccurs=0, maxOccurs="unbounded", nillable=False, encoded=kw.get("encoded")), ns6.PGPData_Dec(minOccurs=0, maxOccurs="unbounded", nillable=False, encoded=kw.get("encoded")), ns6.SPKIData_Dec(minOccurs=0, maxOccurs="unbounded", nillable=False, encoded=kw.get("encoded")), ns6.MgmtData_Dec(minOccurs=0, maxOccurs="unbounded", nillable=False, encoded=kw.get("encoded")), ZSI.TC.AnyElement(aname="_any", minOccurs=0, maxOccurs="unbounded", nillable=False, processContents="lax")]
            self.attribute_typecode_dict = attributes or {}
            if extend: TClist += ofwhat
            if restrict: TClist = ofwhat
            else:
                # attribute handling code
                self.attribute_typecode_dict["Id"] = ZSI.TC.AnyType()
            ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, mixed=True, mixed_aname="_text", **kw)
            class Holder:
                __metaclass__ = pyclass_type
                typecode = self
                def __init__(self):
                    # pyclass
                    self._KeyName = None
                    self._KeyValue = None
                    self._RetrievalMethod = None
                    self._X509Data = None
                    self._PGPData = None
                    self._SPKIData = None
                    self._MgmtData = None
                    self._None = []
                    return
            Holder.__name__ = "KeyInfoType_Holder"
            self.pyclass = Holder

    class KeyValueType_Def(ZSI.TCcompound.ComplexType, TypeDefinition):
        schema = "http://www.w3.org/2000/09/xmldsig#"
        type = (schema, "KeyValueType")
        def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw):
            ns = ns6.KeyValueType_Def.schema
            TClist = [ns6.DSAKeyValue_Dec(minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ns6.RSAKeyValue_Dec(minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ZSI.TC.AnyElement(aname="_any", minOccurs=0, maxOccurs=1, nillable=False, processContents="lax")]
            self.attribute_typecode_dict = attributes or {}
            if extend: TClist += ofwhat
            if restrict: TClist = ofwhat
            ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, mixed=True, mixed_aname="_text", **kw)
            class Holder:
                __metaclass__ = pyclass_type
                typecode = self
                def __init__(self):
                    # pyclass
                    self._DSAKeyValue = None
                    self._RSAKeyValue = None
                    self._None = None
                    return
            Holder.__name__ = "KeyValueType_Holder"
            self.pyclass = Holder

    class RetrievalMethodType_Def(ZSI.TCcompound.ComplexType, TypeDefinition):
        schema = "http://www.w3.org/2000/09/xmldsig#"
        type = (schema, "RetrievalMethodType")
        def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw):
            ns = ns6.RetrievalMethodType_Def.schema
            TClist = [ns6.Transforms_Dec(minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded"))]
            self.attribute_typecode_dict = attributes or {}
            if extend: TClist += ofwhat
            if restrict: TClist = ofwhat
            else:
                # attribute handling code
                self.attribute_typecode_dict["URI"] = ZSI.TC.URI()
                self.attribute_typecode_dict["Type"] = ZSI.TC.URI()
            ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw)
            class Holder:
                __metaclass__ = pyclass_type
                typecode = self
                def __init__(self):
                    # pyclass
                    self._Transforms = None
                    return
            Holder.__name__ = "RetrievalMethodType_Holder"
            self.pyclass = Holder

    class X509DataType_Def(ZSI.TCcompound.ComplexType, TypeDefinition):
        schema = "http://www.w3.org/2000/09/xmldsig#"
        type = (schema, "X509DataType")
        def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw):
            ns = ns6.X509DataType_Def.schema
            TClist = [ns6.X509IssuerSerialType_Def(pname=(ns,"X509IssuerSerial"), aname="_X509IssuerSerial", minOccurs=0, maxOccurs="unbounded", nillable=False, encoded=kw.get("encoded")), ZSI.TC.Base64String(pname=(ns,"X509SKI"), aname="_X509SKI", minOccurs=0, maxOccurs="unbounded", nillable=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"X509SubjectName"), aname="_X509SubjectName", minOccurs=0, maxOccurs="unbounded", nillable=False, encoded=kw.get("encoded")), ZSI.TC.Base64String(pname=(ns,"X509Certificate"), aname="_X509Certificate", minOccurs=0, maxOccurs="unbounded", nillable=False, encoded=kw.get("encoded")), ZSI.TC.Base64String(pname=(ns,"X509CRL"), aname="_X509CRL", minOccurs=0, maxOccurs="unbounded", nillable=False, encoded=kw.get("encoded")), ZSI.TC.AnyElement(aname="_any", minOccurs=0, maxOccurs="unbounded", nillable=False, processContents="lax")]
            self.attribute_typecode_dict = attributes or {}
            if extend: TClist += ofwhat
            if restrict: TClist = ofwhat
            ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw)
            class Holder:
                __metaclass__ = pyclass_type
                typecode = self
                def __init__(self):
                    # pyclass
                    self._X509IssuerSerial = []
                    self._X509SKI = []
                    self._X509SubjectName = []
                    self._X509Certificate = []
                    self._X509CRL = []
                    self._None = []
                    return
            Holder.__name__ = "X509DataType_Holder"
            self.pyclass = Holder

    class X509IssuerSerialType_Def(ZSI.TCcompound.ComplexType, TypeDefinition):
        schema = "http://www.w3.org/2000/09/xmldsig#"
        type = (schema, "X509IssuerSerialType")
        def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw):
            ns = ns6.X509IssuerSerialType_Def.schema
            TClist = [ZSI.TC.String(pname=(ns,"X509IssuerName"), aname="_X509IssuerName", minOccurs=1, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iinteger(pname=(ns,"X509SerialNumber"), aname="_X509SerialNumber", minOccurs=1, maxOccurs=1, nillable=False, encoded=kw.get("encoded"))]
            self.attribute_typecode_dict = attributes or {}
            if extend: TClist += ofwhat
            if restrict: TClist = ofwhat
            ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw)
            class Holder:
                __metaclass__ = pyclass_type
                typecode = self
                def __init__(self):
                    # pyclass
                    self._X509IssuerName = None
                    self._X509SerialNumber = None
                    return
            Holder.__name__ = "X509IssuerSerialType_Holder"
            self.pyclass = Holder

    class PGPDataType_Def(ZSI.TCcompound.ComplexType, TypeDefinition):
        schema = "http://www.w3.org/2000/09/xmldsig#"
        type = (schema, "PGPDataType")
        def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw):
            ns = ns6.PGPDataType_Def.schema
            TClist = [ZSI.TC.Base64String(pname=(ns,"PGPKeyID"), aname="_PGPKeyID", minOccurs=1, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ZSI.TC.Base64String(pname=(ns,"PGPKeyPacket"), aname="_PGPKeyPacket", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ZSI.TC.AnyElement(aname="_any", minOccurs=0, maxOccurs="unbounded", nillable=False, processContents="lax")]
            self.attribute_typecode_dict = attributes or {}
            if extend: TClist += ofwhat
            if restrict: TClist = ofwhat
            ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw)
            class Holder:
                __metaclass__ = pyclass_type
                typecode = self
                def __init__(self):
                    # pyclass
                    self._PGPKeyID = None
                    self._PGPKeyPacket = None
                    self._None = []
                    return
            Holder.__name__ = "PGPDataType_Holder"
            self.pyclass = Holder

    class SPKIDataType_Def(ZSI.TCcompound.ComplexType, TypeDefinition):
        schema = "http://www.w3.org/2000/09/xmldsig#"
        type = (schema, "SPKIDataType")
        def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw):
            ns = ns6.SPKIDataType_Def.schema
            TClist = [ZSI.TC.Base64String(pname=(ns,"SPKISexp"), aname="_SPKISexp", minOccurs=1, maxOccurs="unbounded", nillable=False, encoded=kw.get("encoded")), ZSI.TC.AnyElement(aname="_any", minOccurs=0, maxOccurs="unbounded", nillable=False, processContents="lax")]
            self.attribute_typecode_dict = attributes or {}
            if extend: TClist += ofwhat
            if restrict: TClist = ofwhat
            ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw)
            class Holder:
                __metaclass__ = pyclass_type
                typecode = self
                def __init__(self):
                    # pyclass
                    self._SPKISexp = []
                    self._None = []
                    return
            Holder.__name__ = "SPKIDataType_Holder"
            self.pyclass = Holder

    class ObjectType_Def(ZSI.TCcompound.ComplexType, TypeDefinition):
        schema = "http://www.w3.org/2000/09/xmldsig#"
        type = (schema, "ObjectType")
        def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw):
            ns = ns6.ObjectType_Def.schema
            TClist = [ZSI.TC.AnyElement(aname="_any", minOccurs=0, maxOccurs="unbounded", nillable=False, processContents="lax")]
            self.attribute_typecode_dict = attributes or {}
            if extend: TClist += ofwhat
            if restrict: TClist = ofwhat
            else:
                # attribute handling code
                self.attribute_typecode_dict["Id"] = ZSI.TC.AnyType()
                self.attribute_typecode_dict["MimeType"] = ZSI.TC.String()
                self.attribute_typecode_dict["Encoding"] = ZSI.TC.URI()
            ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, mixed=True, mixed_aname="_text", **kw)
            class Holder:
                __metaclass__ = pyclass_type
                typecode = self
                def __init__(self):
                    # pyclass
                    self._None = []
                    return
            Holder.__name__ = "ObjectType_Holder"
            self.pyclass = Holder

    class ManifestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition):
        schema = "http://www.w3.org/2000/09/xmldsig#"
        type = (schema, "ManifestType")
        def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw):
            ns = ns6.ManifestType_Def.schema
            TClist = [ns6.Reference_Dec(minOccurs=1, maxOccurs="unbounded", nillable=False, encoded=kw.get("encoded"))]
            self.attribute_typecode_dict = attributes or {}
            if extend: TClist += ofwhat
            if restrict: TClist = ofwhat
            else:
                # attribute handling code
                self.attribute_typecode_dict["Id"] = ZSI.TC.AnyType()
            ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw)
            class Holder:
                __metaclass__ = pyclass_type
                typecode = self
                def __init__(self):
                    # pyclass
                    self._Reference = None
                    return
            Holder.__name__ = "ManifestType_Holder"
            self.pyclass = Holder

    class SignaturePropertiesType_Def(ZSI.TCcompound.ComplexType, TypeDefinition):
        schema = "http://www.w3.org/2000/09/xmldsig#"
        type = (schema, "SignaturePropertiesType")
        def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw):
            ns = ns6.SignaturePropertiesType_Def.schema
            TClist = [ns6.SignatureProperty_Dec(minOccurs=1, maxOccurs="unbounded", nillable=False, encoded=kw.get("encoded"))]
            self.attribute_typecode_dict = attributes or {}
            if extend: TClist += ofwhat
            if restrict: TClist = ofwhat
            else:
                # attribute handling code
                self.attribute_typecode_dict["Id"] = ZSI.TC.AnyType()
            ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw)
            class Holder:
                __metaclass__ = pyclass_type
                typecode = self
                def __init__(self):
                    # pyclass
                    self._SignatureProperty = None
                    return
            Holder.__name__ = "SignaturePropertiesType_Holder"
            self.pyclass = Holder

    class SignaturePropertyType_Def(ZSI.TCcompound.ComplexType, TypeDefinition):
        schema = "http://www.w3.org/2000/09/xmldsig#"
        type = (schema, "SignaturePropertyType")
        def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw):
            ns = ns6.SignaturePropertyType_Def.schema
            TClist = [ZSI.TC.AnyElement(aname="_any", minOccurs=0, maxOccurs="unbounded", nillable=False, processContents="lax")]
            self.attribute_typecode_dict = attributes or {}
            if extend: TClist += ofwhat
            if restrict: TClist = ofwhat
            else:
                # attribute handling code
                self.attribute_typecode_dict["Target"] = ZSI.TC.URI()
                self.attribute_typecode_dict["Id"] = ZSI.TC.AnyType()
            ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, mixed=True, mixed_aname="_text", **kw)
            class Holder:
                __metaclass__ = pyclass_type
                typecode = self
                def __init__(self):
                    # pyclass
                    self._None = []
                    return
            Holder.__name__ = "SignaturePropertyType_Holder"
            self.pyclass = Holder

    class HMACOutputLengthType_Def(ZSI.TCnumbers.Iinteger, TypeDefinition):
        schema = "http://www.w3.org/2000/09/xmldsig#"
        type = (schema, "HMACOutputLengthType")
        def __init__(self, pname, **kw):
            ZSI.TCnumbers.Iinteger.__init__(self, pname, pyclass=None, **kw)
            class Holder(int):
                typecode = self
            self.pyclass = Holder

    class DSAKeyValueType_Def(ZSI.TCcompound.ComplexType, TypeDefinition):
        schema = "http://www.w3.org/2000/09/xmldsig#"
        type = (schema, "DSAKeyValueType")
        def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw):
            ns = ns6.DSAKeyValueType_Def.schema
            TClist = [ns6.CryptoBinary_Def(pname=(ns,"P"), aname="_P", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ns6.CryptoBinary_Def(pname=(ns,"Q"), aname="_Q", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ns6.CryptoBinary_Def(pname=(ns,"G"), aname="_G", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ns6.CryptoBinary_Def(pname=(ns,"Y"), aname="_Y", minOccurs=1, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ns6.CryptoBinary_Def(pname=(ns,"J"), aname="_J", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ns6.CryptoBinary_Def(pname=(ns,"Seed"), aname="_Seed", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ns6.CryptoBinary_Def(pname=(ns,"PgenCounter"), aname="_PgenCounter", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded"))]
            self.attribute_typecode_dict = attributes or {}
            if extend: TClist += ofwhat
            if restrict: TClist = ofwhat
            ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw)
            class Holder:
                __metaclass__ = pyclass_type
                typecode = self
                def __init__(self):
                    # pyclass
                    self._P = None
                    self._Q = None
                    self._G = None
                    self._Y = None
                    self._J = None
                    self._Seed = None
                    self._PgenCounter = None
                    return
            Holder.__name__ = "DSAKeyValueType_Holder"
            self.pyclass = Holder

    class RSAKeyValueType_Def(ZSI.TCcompound.ComplexType, TypeDefinition):
        schema = "http://www.w3.org/2000/09/xmldsig#"
        type = (schema, "RSAKeyValueType")
        def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw):
            ns = ns6.RSAKeyValueType_Def.schema
            TClist = [ns6.CryptoBinary_Def(pname=(ns,"Modulus"), aname="_Modulus", minOccurs=1, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ns6.CryptoBinary_Def(pname=(ns,"Exponent"), aname="_Exponent", minOccurs=1, maxOccurs=1, nillable=False, encoded=kw.get("encoded"))]
            self.attribute_typecode_dict = attributes or {}
            if extend: TClist += ofwhat
            if restrict: TClist = ofwhat
            ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw)
            class Holder:
                __metaclass__ = pyclass_type
                typecode = self
                def __init__(self):
                    # pyclass
                    self._Modulus = None
                    self._Exponent = None
                    return
            Holder.__name__ = "RSAKeyValueType_Holder"
            self.pyclass = Holder

    class Signature_Dec(ElementDeclaration):
        literal = "Signature"
        schema = "http://www.w3.org/2000/09/xmldsig#"
        def __init__(self, **kw):
            kw["pname"] = ("http://www.w3.org/2000/09/xmldsig#","Signature")
            kw["aname"] = "_Signature"
            if ns6.SignatureType_Def not in ns6.Signature_Dec.__bases__:
                bases = list(ns6.Signature_Dec.__bases__)
                bases.insert(0, ns6.SignatureType_Def)
                ns6.Signature_Dec.__bases__ = tuple(bases)

            ns6.SignatureType_Def.__init__(self, **kw)
            if self.pyclass is not None: self.pyclass.__name__ = "Signature_Dec_Holder"

    class SignatureValue_Dec(ElementDeclaration):
        literal = "SignatureValue"
        schema = "http://www.w3.org/2000/09/xmldsig#"
        def __init__(self, **kw):
            kw["pname"] = ("http://www.w3.org/2000/09/xmldsig#","SignatureValue")
            kw["aname"] = "_SignatureValue"
            if ns6.SignatureValueType_Def not in ns6.SignatureValue_Dec.__bases__:
                bases = list(ns6.SignatureValue_Dec.__bases__)
                bases.insert(0, ns6.SignatureValueType_Def)
                ns6.SignatureValue_Dec.__bases__ = tuple(bases)

            ns6.SignatureValueType_Def.__init__(self, **kw)
            if self.pyclass is not None: self.pyclass.__name__ = "SignatureValue_Dec_Holder"

    class SignedInfo_Dec(ElementDeclaration):
        literal = "SignedInfo"
        schema = "http://www.w3.org/2000/09/xmldsig#"
        def __init__(self, **kw):
            kw["pname"] = ("http://www.w3.org/2000/09/xmldsig#","SignedInfo")
            kw["aname"] = "_SignedInfo"
            if ns6.SignedInfoType_Def not in ns6.SignedInfo_Dec.__bases__:
                bases = list(ns6.SignedInfo_Dec.__bases__)
                bases.insert(0, ns6.SignedInfoType_Def)
                ns6.SignedInfo_Dec.__bases__ = tuple(bases)

            ns6.SignedInfoType_Def.__init__(self, **kw)
            if self.pyclass is not None: self.pyclass.__name__ = "SignedInfo_Dec_Holder"

    class CanonicalizationMethod_Dec(ElementDeclaration):
        literal = "CanonicalizationMethod"
        schema = "http://www.w3.org/2000/09/xmldsig#"
        def __init__(self, **kw):
            kw["pname"] = ("http://www.w3.org/2000/09/xmldsig#","CanonicalizationMethod")
            kw["aname"] = "_CanonicalizationMethod"
            if ns6.CanonicalizationMethodType_Def not in ns6.CanonicalizationMethod_Dec.__bases__:
                bases = list(ns6.CanonicalizationMethod_Dec.__bases__)
                bases.insert(0, ns6.CanonicalizationMethodType_Def)
                ns6.CanonicalizationMethod_Dec.__bases__ = tuple(bases)

            ns6.CanonicalizationMethodType_Def.__init__(self, **kw)
            if self.pyclass is not None: self.pyclass.__name__ = "CanonicalizationMethod_Dec_Holder"

    class SignatureMethod_Dec(ElementDeclaration):
        literal = "SignatureMethod"
        schema = "http://www.w3.org/2000/09/xmldsig#"
        def __init__(self, **kw):
            kw["pname"] = ("http://www.w3.org/2000/09/xmldsig#","SignatureMethod")
            kw["aname"] = "_SignatureMethod"
            if ns6.SignatureMethodType_Def not in ns6.SignatureMethod_Dec.__bases__:
                bases = list(ns6.SignatureMethod_Dec.__bases__)
                bases.insert(0, ns6.SignatureMethodType_Def)
                ns6.SignatureMethod_Dec.__bases__ = tuple(bases)

            ns6.SignatureMethodType_Def.__init__(self, **kw)
            if self.pyclass is not None: self.pyclass.__name__ = "SignatureMethod_Dec_Holder"

    class Reference_Dec(ElementDeclaration):
        literal = "Reference"
        schema = "http://www.w3.org/2000/09/xmldsig#"
        def __init__(self, **kw):
            kw["pname"] = ("http://www.w3.org/2000/09/xmldsig#","Reference")
            kw["aname"] = "_Reference"
            if ns6.ReferenceType_Def not in ns6.Reference_Dec.__bases__:
                bases = list(ns6.Reference_Dec.__bases__)
                bases.insert(0, ns6.ReferenceType_Def)
                ns6.Reference_Dec.__bases__ = tuple(bases)

            ns6.ReferenceType_Def.__init__(self, **kw)
            if self.pyclass is not None: self.pyclass.__name__ = "Reference_Dec_Holder"

    class Transforms_Dec(ElementDeclaration):
        literal = "Transforms"
        schema = "http://www.w3.org/2000/09/xmldsig#"
        def __init__(self, **kw):
            kw["pname"] = ("http://www.w3.org/2000/09/xmldsig#","Transforms")
            kw["aname"] = "_Transforms"
            if ns6.TransformsType_Def not in ns6.Transforms_Dec.__bases__:
                bases = list(ns6.Transforms_Dec.__bases__)
                bases.insert(0, ns6.TransformsType_Def)
                ns6.Transforms_Dec.__bases__ = tuple(bases)

            ns6.TransformsType_Def.__init__(self, **kw)
            if self.pyclass is not None: self.pyclass.__name__ = "Transforms_Dec_Holder"

    class Transform_Dec(ElementDeclaration):
        literal = "Transform"
        schema = "http://www.w3.org/2000/09/xmldsig#"
        def __init__(self, **kw):
            kw["pname"] = ("http://www.w3.org/2000/09/xmldsig#","Transform")
            kw["aname"] = "_Transform"
            if ns6.TransformType_Def not in ns6.Transform_Dec.__bases__:
                bases = list(ns6.Transform_Dec.__bases__)
                bases.insert(0, ns6.TransformType_Def)
                ns6.Transform_Dec.__bases__ = tuple(bases)

            ns6.TransformType_Def.__init__(self, **kw)
            if self.pyclass is not None: self.pyclass.__name__ = "Transform_Dec_Holder"

    class DigestMethod_Dec(ElementDeclaration):
        literal = "DigestMethod"
        schema = "http://www.w3.org/2000/09/xmldsig#"
        def __init__(self, **kw):
            kw["pname"] = ("http://www.w3.org/2000/09/xmldsig#","DigestMethod")
            kw["aname"] = "_DigestMethod"
            if ns6.DigestMethodType_Def not in ns6.DigestMethod_Dec.__bases__:
                bases = list(ns6.DigestMethod_Dec.__bases__)
                bases.insert(0, ns6.DigestMethodType_Def)
                ns6.DigestMethod_Dec.__bases__ = tuple(bases)

            ns6.DigestMethodType_Def.__init__(self, **kw)
            if self.pyclass is not None: self.pyclass.__name__ = "DigestMethod_Dec_Holder"

    class DigestValue_Dec(ElementDeclaration):
        literal = "DigestValue"
        schema = "http://www.w3.org/2000/09/xmldsig#"
        def __init__(self, **kw):
            kw["pname"] = ("http://www.w3.org/2000/09/xmldsig#","DigestValue")
            kw["aname"] = "_DigestValue"
            if ns6.DigestValueType_Def not in ns6.DigestValue_Dec.__bases__:
                bases = list(ns6.DigestValue_Dec.__bases__)
                bases.insert(0, ns6.DigestValueType_Def)
                ns6.DigestValue_Dec.__bases__ = tuple(bases)

            ns6.DigestValueType_Def.__init__(self, **kw)
            if self.pyclass is not None: self.pyclass.__name__ = "DigestValue_Dec_Holder"

    class KeyInfo_Dec(ElementDeclaration):
        literal = "KeyInfo"
        schema = "http://www.w3.org/2000/09/xmldsig#"
        def __init__(self, **kw):
            kw["pname"] = ("http://www.w3.org/2000/09/xmldsig#","KeyInfo")
            kw["aname"] = "_KeyInfo"
            if ns6.KeyInfoType_Def not in ns6.KeyInfo_Dec.__bases__:
                bases = list(ns6.KeyInfo_Dec.__bases__)
                bases.insert(0, ns6.KeyInfoType_Def)
                ns6.KeyInfo_Dec.__bases__ = tuple(bases)

            ns6.KeyInfoType_Def.__init__(self, **kw)
            if self.pyclass is not None: self.pyclass.__name__ = "KeyInfo_Dec_Holder"

    class KeyName_Dec(ZSI.TC.String, ElementDeclaration):
        literal = "KeyName"
        schema = "http://www.w3.org/2000/09/xmldsig#"
        def __init__(self, **kw):
            kw["pname"] = ("http://www.w3.org/2000/09/xmldsig#","KeyName")
            kw["aname"] = "_KeyName"
            class IHolder(str): typecode=self
            kw["pyclass"] = IHolder
            IHolder.__name__ = "_KeyName_immutable_holder"
            ZSI.TC.String.__init__(self, **kw)

    class MgmtData_Dec(ZSI.TC.String, ElementDeclaration):
        literal = "MgmtData"
        schema = "http://www.w3.org/2000/09/xmldsig#"
        def __init__(self, **kw):
            kw["pname"] = ("http://www.w3.org/2000/09/xmldsig#","MgmtData")
            kw["aname"] = "_MgmtData"
            class IHolder(str): typecode=self
            kw["pyclass"] = IHolder
            IHolder.__name__ = "_MgmtData_immutable_holder"
            ZSI.TC.String.__init__(self, **kw)

    class KeyValue_Dec(ElementDeclaration):
        literal = "KeyValue"
        schema = "http://www.w3.org/2000/09/xmldsig#"
        def __init__(self, **kw):
            kw["pname"] = ("http://www.w3.org/2000/09/xmldsig#","KeyValue")
            kw["aname"] = "_KeyValue"
            if ns6.KeyValueType_Def not in ns6.KeyValue_Dec.__bases__:
                bases = list(ns6.KeyValue_Dec.__bases__)
                bases.insert(0, ns6.KeyValueType_Def)
                ns6.KeyValue_Dec.__bases__ = tuple(bases)

            ns6.KeyValueType_Def.__init__(self, **kw)
            if self.pyclass is not None: self.pyclass.__name__ = "KeyValue_Dec_Holder"

    class RetrievalMethod_Dec(ElementDeclaration):
        literal = "RetrievalMethod"
        schema = "http://www.w3.org/2000/09/xmldsig#"
        def __init__(self, **kw):
            kw["pname"] = ("http://www.w3.org/2000/09/xmldsig#","RetrievalMethod")
            kw["aname"] = "_RetrievalMethod"
            if ns6.RetrievalMethodType_Def not in ns6.RetrievalMethod_Dec.__bases__:
                bases = list(ns6.RetrievalMethod_Dec.__bases__)
                bases.insert(0, ns6.RetrievalMethodType_Def)
                ns6.RetrievalMethod_Dec.__bases__ = tuple(bases)

            ns6.RetrievalMethodType_Def.__init__(self, **kw)
            if self.pyclass is not None: self.pyclass.__name__ = "RetrievalMethod_Dec_Holder"

    class X509Data_Dec(ElementDeclaration):
        literal = "X509Data"
        schema = "http://www.w3.org/2000/09/xmldsig#"
        def __init__(self, **kw):
            kw["pname"] = ("http://www.w3.org/2000/09/xmldsig#","X509Data")
            kw["aname"] = "_X509Data"
            if ns6.X509DataType_Def not in ns6.X509Data_Dec.__bases__:
                bases = list(ns6.X509Data_Dec.__bases__)
                bases.insert(0, ns6.X509DataType_Def)
                ns6.X509Data_Dec.__bases__ = tuple(bases)

            ns6.X509DataType_Def.__init__(self, **kw)
            if self.pyclass is not None: self.pyclass.__name__ = "X509Data_Dec_Holder"

    class PGPData_Dec(ElementDeclaration):
        literal = "PGPData"
        schema = "http://www.w3.org/2000/09/xmldsig#"
        def __init__(self, **kw):
            kw["pname"] = ("http://www.w3.org/2000/09/xmldsig#","PGPData")
            kw["aname"] = "_PGPData"
            if ns6.PGPDataType_Def not in ns6.PGPData_Dec.__bases__:
                bases = list(ns6.PGPData_Dec.__bases__)
                bases.insert(0, ns6.PGPDataType_Def)
                ns6.PGPData_Dec.__bases__ = tuple(bases)

            ns6.PGPDataType_Def.__init__(self, **kw)
            if self.pyclass is not None: self.pyclass.__name__ = "PGPData_Dec_Holder"

    class SPKIData_Dec(ElementDeclaration):
        literal = "SPKIData"
        schema = "http://www.w3.org/2000/09/xmldsig#"
        def __init__(self, **kw):
            kw["pname"] = ("http://www.w3.org/2000/09/xmldsig#","SPKIData")
            kw["aname"] = "_SPKIData"
            if ns6.SPKIDataType_Def not in ns6.SPKIData_Dec.__bases__:
                bases = list(ns6.SPKIData_Dec.__bases__)
                bases.insert(0, ns6.SPKIDataType_Def)
                ns6.SPKIData_Dec.__bases__ = tuple(bases)

            ns6.SPKIDataType_Def.__init__(self, **kw)
            if self.pyclass is not None: self.pyclass.__name__ = "SPKIData_Dec_Holder"

    class Object_Dec(ElementDeclaration):
        literal = "Object"
        schema = "http://www.w3.org/2000/09/xmldsig#"
        def __init__(self, **kw):
            kw["pname"] = ("http://www.w3.org/2000/09/xmldsig#","Object")
            kw["aname"] = "_Object"
            if ns6.ObjectType_Def not in ns6.Object_Dec.__bases__:
                bases = list(ns6.Object_Dec.__bases__)
                bases.insert(0, ns6.ObjectType_Def)
                ns6.Object_Dec.__bases__ = tuple(bases)

            ns6.ObjectType_Def.__init__(self, **kw)
            if self.pyclass is not None: self.pyclass.__name__ = "Object_Dec_Holder"

    class Manifest_Dec(ElementDeclaration):
        literal = "Manifest"
        schema = "http://www.w3.org/2000/09/xmldsig#"
        def __init__(self, **kw):
            kw["pname"] = ("http://www.w3.org/2000/09/xmldsig#","Manifest")
            kw["aname"] = "_Manifest"
            if ns6.ManifestType_Def not in ns6.Manifest_Dec.__bases__:
                bases = list(ns6.Manifest_Dec.__bases__)
                bases.insert(0, ns6.ManifestType_Def)
                ns6.Manifest_Dec.__bases__ = tuple(bases)

            ns6.ManifestType_Def.__init__(self, **kw)
            if self.pyclass is not None: self.pyclass.__name__ = "Manifest_Dec_Holder"

    class SignatureProperties_Dec(ElementDeclaration):
        literal = "SignatureProperties"
        schema = "http://www.w3.org/2000/09/xmldsig#"
        def __init__(self, **kw):
            kw["pname"] = ("http://www.w3.org/2000/09/xmldsig#","SignatureProperties")
            kw["aname"] = "_SignatureProperties"
            if ns6.SignaturePropertiesType_Def not in ns6.SignatureProperties_Dec.__bases__:
                bases = list(ns6.SignatureProperties_Dec.__bases__)
                bases.insert(0, ns6.SignaturePropertiesType_Def)
                ns6.SignatureProperties_Dec.__bases__ = tuple(bases)

            ns6.SignaturePropertiesType_Def.__init__(self, **kw)
            if self.pyclass is not None: self.pyclass.__name__ = "SignatureProperties_Dec_Holder"

    class SignatureProperty_Dec(ElementDeclaration):
        literal = "SignatureProperty"
        schema = "http://www.w3.org/2000/09/xmldsig#"
        def __init__(self, **kw):
            kw["pname"] = ("http://www.w3.org/2000/09/xmldsig#","SignatureProperty")
            kw["aname"] = "_SignatureProperty"
            if ns6.SignaturePropertyType_Def not in ns6.SignatureProperty_Dec.__bases__:
                bases = list(ns6.SignatureProperty_Dec.__bases__)
                bases.insert(0, ns6.SignaturePropertyType_Def)
                ns6.SignatureProperty_Dec.__bases__ = tuple(bases)

            ns6.SignaturePropertyType_Def.__init__(self, **kw)
            if self.pyclass is not None: self.pyclass.__name__ = "SignatureProperty_Dec_Holder"

    class DSAKeyValue_Dec(ElementDeclaration):
        literal = "DSAKeyValue"
        schema = "http://www.w3.org/2000/09/xmldsig#"
        def __init__(self, **kw):
            kw["pname"] = ("http://www.w3.org/2000/09/xmldsig#","DSAKeyValue")
            kw["aname"] = "_DSAKeyValue"
            if ns6.DSAKeyValueType_Def not in ns6.DSAKeyValue_Dec.__bases__:
                bases = list(ns6.DSAKeyValue_Dec.__bases__)
                bases.insert(0, ns6.DSAKeyValueType_Def)
                ns6.DSAKeyValue_Dec.__bases__ = tuple(bases)

            ns6.DSAKeyValueType_Def.__init__(self, **kw)
            if self.pyclass is not None: self.pyclass.__name__ = "DSAKeyValue_Dec_Holder"

    class RSAKeyValue_Dec(ElementDeclaration):
        literal = "RSAKeyValue"
        schema = "http://www.w3.org/2000/09/xmldsig#"
        def __init__(self, **kw):
            kw["pname"] = ("http://www.w3.org/2000/09/xmldsig#","RSAKeyValue")
            kw["aname"] = "_RSAKeyValue"
            if ns6.RSAKeyValueType_Def not in ns6.RSAKeyValue_Dec.__bases__:
                bases = list(ns6.RSAKeyValue_Dec.__bases__)
                bases.insert(0, ns6.RSAKeyValueType_Def)
                ns6.RSAKeyValue_Dec.__bases__ = tuple(bases)

            ns6.RSAKeyValueType_Def.__init__(self, **kw)
            if self.pyclass is not None: self.pyclass.__name__ = "RSAKeyValue_Dec_Holder"

# end class ns6 (tns: http://www.w3.org/2000/09/xmldsig#)

##############################
# targetNamespace
# http://www.opentravel.org/OTA/2002/11
##############################

class ns4:
    targetNamespace = "http://www.opentravel.org/OTA/2002/11"

    class SessionCreateRQ_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration):
        schema = "http://www.opentravel.org/OTA/2002/11"
        literal = "SessionCreateRQ"
        def __init__(self, **kw):
            ns = ns4.SessionCreateRQ_Dec.schema
            TClist = [self.__class__.POS_Dec(minOccurs=1, maxOccurs=1, nillable=False, encoded=kw.get("encoded"))]
            kw["pname"] = ("http://www.opentravel.org/OTA/2002/11","SessionCreateRQ")
            kw["aname"] = "_SessionCreateRQ"
            self.attribute_typecode_dict = {}
            ZSI.TCcompound.ComplexType.__init__(self, None, TClist, inorder=0, **kw)
            class Holder:
                __metaclass__ = pyclass_type
                typecode = self
                def __init__(self):
                    # pyclass
                    self._POS = None
                    return
            Holder.__name__ = "SessionCreateRQ_Holder"
            self.pyclass = Holder


        class POS_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration):
            schema = "http://www.opentravel.org/OTA/2002/11"
            literal = "POS"
            def __init__(self, **kw):
                ns = ns4.SessionCreateRQ_Dec.POS_Dec.schema
                TClist = [self.__class__.Source_Dec(minOccurs=1, maxOccurs=1, nillable=False, encoded=kw.get("encoded"))]
                kw["pname"] = ("http://www.opentravel.org/OTA/2002/11","POS")
                kw["aname"] = "_POS"
                self.attribute_typecode_dict = {}
                ZSI.TCcompound.ComplexType.__init__(self, None, TClist, inorder=0, **kw)
                class Holder:
                    __metaclass__ = pyclass_type
                    typecode = self
                    def __init__(self):
                        # pyclass
                        self._Source = None
                        return
                Holder.__name__ = "POS_Holder"
                self.pyclass = Holder


            class Source_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration):
                schema = "http://www.opentravel.org/OTA/2002/11"
                literal = "Source"
                def __init__(self, **kw):
                    ns = ns4.SessionCreateRQ_Dec.POS_Dec.Source_Dec.schema
                    TClist = []
                    kw["pname"] = ("http://www.opentravel.org/OTA/2002/11","Source")
                    kw["aname"] = "_Source"
                    self.attribute_typecode_dict = {}
                    ZSI.TCcompound.ComplexType.__init__(self, None, TClist, inorder=0, **kw)
                    # attribute handling code
                    self.attribute_typecode_dict["PseudoCityCode"] = ZSI.TC.String()
                    class Holder:
                        __metaclass__ = pyclass_type
                        typecode = self
                        def __init__(self):
                            # pyclass
                            return
                    Holder.__name__ = "Source_Holder"
                    self.pyclass = Holder







    class SessionCreateRS_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration):
        schema = "http://www.opentravel.org/OTA/2002/11"
        literal = "SessionCreateRS"
        def __init__(self, **kw):
            ns = ns4.SessionCreateRS_Dec.schema
            TClist = [self.__class__.Success_Dec(minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), self.__class__.Warnings_Dec(minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"ConversationId"), aname="_ConversationId", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), self.__class__.Errors_Dec(minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded"))]
            kw["pname"] = ("http://www.opentravel.org/OTA/2002/11","SessionCreateRS")
            kw["aname"] = "_SessionCreateRS"
            self.attribute_typecode_dict = {}
            ZSI.TCcompound.ComplexType.__init__(self, None, TClist, inorder=0, **kw)
            # attribute handling code
            self.attribute_typecode_dict["EchoToken"] = ZSI.TC.String()
            self.attribute_typecode_dict["TimeStamp"] = ZSI.TC.String()
            self.attribute_typecode_dict["Target"] = ZSI.TC.String()
            self.attribute_typecode_dict["version"] = ZSI.TC.String()
            self.attribute_typecode_dict["SequenceNmbr"] = ZSI.TCnumbers.InonNegativeInteger()
            self.attribute_typecode_dict["PrimaryLangID"] = ZSI.TC.AnyType()
            self.attribute_typecode_dict["AltLangID"] = ZSI.TC.AnyType()
            self.attribute_typecode_dict["status"] = ZSI.TC.String()
            class Holder:
                __metaclass__ = pyclass_type
                typecode = self
                def __init__(self):
                    # pyclass
                    self._Success = None
                    self._Warnings = None
                    self._ConversationId = None
                    self._Errors = None
                    return
            Holder.__name__ = "SessionCreateRS_Holder"
            self.pyclass = Holder


        class Success_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration):
            schema = "http://www.opentravel.org/OTA/2002/11"
            literal = "Success"
            def __init__(self, **kw):
                ns = ns4.SessionCreateRS_Dec.Success_Dec.schema
                TClist = []
                kw["pname"] = ("http://www.opentravel.org/OTA/2002/11","Success")
                kw["aname"] = "_Success"
                self.attribute_typecode_dict = {}
                ZSI.TCcompound.ComplexType.__init__(self, None, TClist, inorder=0, **kw)
                class Holder:
                    __metaclass__ = pyclass_type
                    typecode = self
                    def __init__(self):
                        # pyclass
                        return
                Holder.__name__ = "Success_Holder"
                self.pyclass = Holder





        class Warnings_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration):
            schema = "http://www.opentravel.org/OTA/2002/11"
            literal = "Warnings"
            def __init__(self, **kw):
                ns = ns4.SessionCreateRS_Dec.Warnings_Dec.schema
                TClist = [self.__class__.Warning_Dec(minOccurs=1, maxOccurs=1, nillable=False, encoded=kw.get("encoded"))]
                kw["pname"] = ("http://www.opentravel.org/OTA/2002/11","Warnings")
                kw["aname"] = "_Warnings"
                self.attribute_typecode_dict = {}
                ZSI.TCcompound.ComplexType.__init__(self, None, TClist, inorder=0, **kw)
                class Holder:
                    __metaclass__ = pyclass_type
                    typecode = self
                    def __init__(self):
                        # pyclass
                        self._Warning = None
                        return
                Holder.__name__ = "Warnings_Holder"
                self.pyclass = Holder


            class Warning_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration):
                schema = "http://www.opentravel.org/OTA/2002/11"
                literal = "Warning"
                def __init__(self, **kw):
                    ns = ns4.SessionCreateRS_Dec.Warnings_Dec.Warning_Dec.schema
                    TClist = []
                    kw["pname"] = ("http://www.opentravel.org/OTA/2002/11","Warning")
                    kw["aname"] = "_Warning"
                    self.attribute_typecode_dict = {}
                    ZSI.TCcompound.ComplexType.__init__(self, None, TClist, inorder=0, **kw)
                    # attribute handling code
                    self.attribute_typecode_dict["Language"] = ZSI.TC.String()
                    self.attribute_typecode_dict["ShortText"] = ZSI.TC.String()
                    self.attribute_typecode_dict["Type"] = ZSI.TC.String()
                    self.attribute_typecode_dict["Code"] = ZSI.TC.String()
                    self.attribute_typecode_dict["DocURL"] = ZSI.TC.URI()
                    self.attribute_typecode_dict["Status"] = ZSI.TC.String()
                    self.attribute_typecode_dict["Tag"] = ZSI.TC.String()
                    self.attribute_typecode_dict["RecordId"] = ZSI.TC.String()
                    class Holder:
                        __metaclass__ = pyclass_type
                        typecode = self
                        def __init__(self):
                            # pyclass
                            return
                    Holder.__name__ = "Warning_Holder"
                    self.pyclass = Holder








        class Errors_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration):
            schema = "http://www.opentravel.org/OTA/2002/11"
            literal = "Errors"
            def __init__(self, **kw):
                ns = ns4.SessionCreateRS_Dec.Errors_Dec.schema
                TClist = [self.__class__.Error_Dec(minOccurs=1, maxOccurs=1, nillable=False, encoded=kw.get("encoded"))]
                kw["pname"] = ("http://www.opentravel.org/OTA/2002/11","Errors")
                kw["aname"] = "_Errors"
                self.attribute_typecode_dict = {}
                ZSI.TCcompound.ComplexType.__init__(self, None, TClist, inorder=0, **kw)
                class Holder:
                    __metaclass__ = pyclass_type
                    typecode = self
                    def __init__(self):
                        # pyclass
                        self._Error = None
                        return
                Holder.__name__ = "Errors_Holder"
                self.pyclass = Holder


            class Error_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration):
                schema = "http://www.opentravel.org/OTA/2002/11"
                literal = "Error"
                def __init__(self, **kw):
                    ns = ns4.SessionCreateRS_Dec.Errors_Dec.Error_Dec.schema
                    TClist = [self.__class__.ErrorInfo_Dec(minOccurs=1, maxOccurs=1, nillable=False, encoded=kw.get("encoded"))]
                    kw["pname"] = ("http://www.opentravel.org/OTA/2002/11","Error")
                    kw["aname"] = "_Error"
                    self.attribute_typecode_dict = {}
                    ZSI.TCcompound.ComplexType.__init__(self, None, TClist, inorder=0, **kw)
                    # attribute handling code
                    self.attribute_typecode_dict["ErrorCode"] = ZSI.TC.String()
                    self.attribute_typecode_dict["Severity"] = ZSI.TC.String()
                    self.attribute_typecode_dict["ErrorMessage"] = ZSI.TC.String()
                    class Holder:
                        __metaclass__ = pyclass_type
                        typecode = self
                        def __init__(self):
                            # pyclass
                            self._ErrorInfo = None
                            return
                    Holder.__name__ = "Error_Holder"
                    self.pyclass = Holder


                class ErrorInfo_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration):
                    schema = "http://www.opentravel.org/OTA/2002/11"
                    literal = "ErrorInfo"
                    def __init__(self, **kw):
                        ns = ns4.SessionCreateRS_Dec.Errors_Dec.Error_Dec.ErrorInfo_Dec.schema
                        TClist = [ZSI.TC.String(pname=(ns,"Message"), aname="_Message", minOccurs=1, maxOccurs=1, nillable=False, encoded=kw.get("encoded"))]
                        kw["pname"] = ("http://www.opentravel.org/OTA/2002/11","ErrorInfo")
                        kw["aname"] = "_ErrorInfo"
                        self.attribute_typecode_dict = {}
                        ZSI.TCcompound.ComplexType.__init__(self, None, TClist, inorder=0, **kw)
                        class Holder:
                            __metaclass__ = pyclass_type
                            typecode = self
                            def __init__(self):
                                # pyclass
                                self._Message = None
                                return
                        Holder.__name__ = "ErrorInfo_Holder"
                        self.pyclass = Holder










# end class ns4 (tns: http://www.opentravel.org/OTA/2002/11)

##############################
# targetNamespace
# http://www.ebxml.org/namespaces/messageHeader
##############################

class ns5:
    targetNamespace = "http://www.ebxml.org/namespaces/messageHeader"

    class sequenceNumber_type_Def(ZSI.TCnumbers.InonNegativeInteger, TypeDefinition):
        # ComplexType/SimpleContent derivation of built-in type
        schema = "http://www.ebxml.org/namespaces/messageHeader"
        type = (schema, "sequenceNumber.type")
        def __init__(self, pname, **kw):
            if getattr(self, "attribute_typecode_dict", None) is None: self.attribute_typecode_dict = {}
            # attribute handling code
            self.attribute_typecode_dict[("http://www.ebxml.org/namespaces/messageHeader","status")] = ns5.status_type_Def(None)
            ZSI.TCnumbers.InonNegativeInteger.__init__(self, pname, **kw)
            class Holder(int):
                __metaclass__ = pyclass_type
                typecode = self
            self.pyclass = Holder

    class status_type_Def(ZSI.TC.AnyType, TypeDefinition):
        schema = "http://www.ebxml.org/namespaces/messageHeader"
        type = (schema, "status.type")
        def __init__(self, pname, **kw):
            ZSI.TC.AnyType.__init__(self, pname, **kw)

    class messageStatus_type_Def(ZSI.TC.AnyType, TypeDefinition):
        schema = "http://www.ebxml.org/namespaces/messageHeader"
        type = (schema, "messageStatus.type")
        def __init__(self, pname, **kw):
            ZSI.TC.AnyType.__init__(self, pname, **kw)

    class non_empty_string_Def(ZSI.TC.String, TypeDefinition):
        schema = "http://www.ebxml.org/namespaces/messageHeader"
        type = (schema, "non-empty-string")
        def __init__(self, pname, **kw):
            ZSI.TC.String.__init__(self, pname, pyclass=None, **kw)
            class Holder(str):
                typecode = self
            self.pyclass = Holder

    class severity_type_Def(ZSI.TC.AnyType, TypeDefinition):
        schema = "http://www.ebxml.org/namespaces/messageHeader"
        type = (schema, "severity.type")
        def __init__(self, pname, **kw):
            ZSI.TC.AnyType.__init__(self, pname, **kw)

    class Manifest_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration):
        schema = "http://www.ebxml.org/namespaces/messageHeader"
        literal = "Manifest"
        def __init__(self, **kw):
            ns = ns5.Manifest_Dec.schema
            TClist = [ns5.Reference_Dec(minOccurs=1, maxOccurs="unbounded", nillable=False, encoded=kw.get("encoded")), ZSI.TC.AnyElement(aname="_any", minOccurs=0, maxOccurs="unbounded", nillable=False, processContents="lax")]
            kw["pname"] = ("http://www.ebxml.org/namespaces/messageHeader","Manifest")
            kw["aname"] = "_Manifest"
            self.attribute_typecode_dict = {}
            ZSI.TCcompound.ComplexType.__init__(self, None, TClist, inorder=0, **kw)
            # attribute handling code
            self.attribute_typecode_dict[("http://www.ebxml.org/namespaces/messageHeader","id")] = ZSI.TC.AnyType()
            self.attribute_typecode_dict[("http://www.ebxml.org/namespaces/messageHeader","version")] = ns5.non_empty_string_Def(None)
            self.attribute_typecode_dict[("http://www.w3.org/2001/XMLSchema","anyAttribute")] = ZSI.TC.AnyElement()
            class Holder:
                __metaclass__ = pyclass_type
                typecode = self
                def __init__(self):
                    # pyclass
                    self._Reference = None
                    self._None = []
                    return
            Holder.__name__ = "Manifest_Holder"
            self.pyclass = Holder

    class Reference_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration):
        schema = "http://www.ebxml.org/namespaces/messageHeader"
        literal = "Reference"
        def __init__(self, **kw):
            ns = ns5.Reference_Dec.schema
            TClist = [ns5.Schema_Dec(minOccurs=0, maxOccurs="unbounded", nillable=False, encoded=kw.get("encoded")), ns5.Description_Dec(minOccurs=0, maxOccurs="unbounded", nillable=False, encoded=kw.get("encoded")), ZSI.TC.AnyElement(aname="_any", minOccurs=0, maxOccurs="unbounded", nillable=False, processContents="lax")]
            kw["pname"] = ("http://www.ebxml.org/namespaces/messageHeader","Reference")
            kw["aname"] = "_Reference"
            self.attribute_typecode_dict = {}
            ZSI.TCcompound.ComplexType.__init__(self, None, TClist, inorder=0, **kw)
            # attribute handling code
            self.attribute_typecode_dict[("http://www.ebxml.org/namespaces/messageHeader","id")] = ZSI.TC.AnyType()
            self.attribute_typecode_dict[("http://www.w3.org/1999/xlink","type")] = ZSI.TC.String()
            self.attribute_typecode_dict[("http://www.w3.org/1999/xlink","href")] = ZSI.TC.URI()
            self.attribute_typecode_dict[("http://www.w3.org/1999/xlink","role")] = ZSI.TC.URI()
            self.attribute_typecode_dict[("http://www.w3.org/2001/XMLSchema","anyAttribute")] = ZSI.TC.AnyElement()
            class Holder:
                __metaclass__ = pyclass_type
                typecode = self
                def __init__(self):
                    # pyclass
                    self._Schema = None
                    self._Description = None
                    self._None = []
                    return
            Holder.__name__ = "Reference_Holder"
            self.pyclass = Holder

    class Schema_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration):
        schema = "http://www.ebxml.org/namespaces/messageHeader"
        literal = "Schema"
        def __init__(self, **kw):
            ns = ns5.Schema_Dec.schema
            TClist = []
            kw["pname"] = ("http://www.ebxml.org/namespaces/messageHeader","Schema")
            kw["aname"] = "_Schema"
            self.attribute_typecode_dict = {}
            ZSI.TCcompound.ComplexType.__init__(self, None, TClist, inorder=0, **kw)
            # attribute handling code
            self.attribute_typecode_dict[("http://www.ebxml.org/namespaces/messageHeader","location")] = ZSI.TC.URI()
            self.attribute_typecode_dict[("http://www.ebxml.org/namespaces/messageHeader","version")] = ns5.non_empty_string_Def(None)
            class Holder:
                __metaclass__ = pyclass_type
                typecode = self
                def __init__(self):
                    # pyclass
                    return
            Holder.__name__ = "Schema_Holder"
            self.pyclass = Holder

    class MessageHeader_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration):
        schema = "http://www.ebxml.org/namespaces/messageHeader"
        literal = "MessageHeader"
        def __init__(self, **kw):
            ns = ns5.MessageHeader_Dec.schema
            TClist = [ns5.From_Dec(minOccurs=1, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ns5.To_Dec(minOccurs=1, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ns5.CPAId_Dec(minOccurs=1, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ns5.ConversationId_Dec(minOccurs=1, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ns5.Service_Dec(minOccurs=1, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ns5.Action_Dec(minOccurs=1, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ns5.MessageData_Dec(minOccurs=1, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ns5.DuplicateElimination_Dec(minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ns5.Description_Dec(minOccurs=0, maxOccurs="unbounded", nillable=False, encoded=kw.get("encoded")), ZSI.TC.AnyElement(aname="_any", minOccurs=0, maxOccurs="unbounded", nillable=False, processContents="lax")]
            kw["pname"] = ("http://www.ebxml.org/namespaces/messageHeader","MessageHeader")
            kw["aname"] = "_MessageHeader"
            self.attribute_typecode_dict = {}
            ZSI.TCcompound.ComplexType.__init__(self, None, TClist, inorder=0, **kw)
            # attribute handling code
            self.attribute_typecode_dict[("http://www.ebxml.org/namespaces/messageHeader","id")] = ZSI.TC.AnyType()
            self.attribute_typecode_dict[("http://www.ebxml.org/namespaces/messageHeader","version")] = ns5.non_empty_string_Def(None)
            self.attribute_typecode_dict[("http://www.w3.org/2001/XMLSchema","anyAttribute")] = ZSI.TC.AnyElement()
            class Holder:
                __metaclass__ = pyclass_type
                typecode = self
                def __init__(self):
                    # pyclass
                    self._From = None
                    self._To = None
                    self._CPAId = None
                    self._ConversationId = None
                    self._Service = None
                    self._Action = None
                    self._MessageData = None
                    self._DuplicateElimination = None
                    self._Description = None
                    self._None = []
                    return
            Holder.__name__ = "MessageHeader_Holder"
            self.pyclass = Holder

    class CPAId_Dec(ElementDeclaration):
        literal = "CPAId"
        schema = "http://www.ebxml.org/namespaces/messageHeader"
        def __init__(self, **kw):
            kw["pname"] = ("http://www.ebxml.org/namespaces/messageHeader","CPAId")
            kw["aname"] = "_CPAId"
            if ns5.non_empty_string_Def not in ns5.CPAId_Dec.__bases__:
                bases = list(ns5.CPAId_Dec.__bases__)
                bases.insert(0, ns5.non_empty_string_Def)
                ns5.CPAId_Dec.__bases__ = tuple(bases)

            ns5.non_empty_string_Def.__init__(self, **kw)
            if self.pyclass is not None: self.pyclass.__name__ = "CPAId_Dec_Holder"

    class ConversationId_Dec(ElementDeclaration):
        literal = "ConversationId"
        schema = "http://www.ebxml.org/namespaces/messageHeader"
        def __init__(self, **kw):
            kw["pname"] = ("http://www.ebxml.org/namespaces/messageHeader","ConversationId")
            kw["aname"] = "_ConversationId"
            if ns5.non_empty_string_Def not in ns5.ConversationId_Dec.__bases__:
                bases = list(ns5.ConversationId_Dec.__bases__)
                bases.insert(0, ns5.non_empty_string_Def)
                ns5.ConversationId_Dec.__bases__ = tuple(bases)

            ns5.non_empty_string_Def.__init__(self, **kw)
            if self.pyclass is not None: self.pyclass.__name__ = "ConversationId_Dec_Holder"

    class Service_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration):
        schema = "http://www.ebxml.org/namespaces/messageHeader"
        literal = "Service"
        def __init__(self, **kw):
            ns = ns5.Service_Dec.schema
            TClist = []
            kw["pname"] = ("http://www.ebxml.org/namespaces/messageHeader","Service")
            kw["aname"] = "_Service"
            self.attribute_typecode_dict = {}
            ZSI.TCcompound.ComplexType.__init__(self, None, TClist, inorder=0, **kw)
            class Holder:
                __metaclass__ = pyclass_type
                typecode = self
                def __init__(self):
                    # pyclass
                    return
            Holder.__name__ = "Service_Holder"
            self.pyclass = Holder

    class Action_Dec(ElementDeclaration):
        literal = "Action"
        schema = "http://www.ebxml.org/namespaces/messageHeader"
        def __init__(self, **kw):
            kw["pname"] = ("http://www.ebxml.org/namespaces/messageHeader","Action")
            kw["aname"] = "_Action"
            if ns5.non_empty_string_Def not in ns5.Action_Dec.__bases__:
                bases = list(ns5.Action_Dec.__bases__)
                bases.insert(0, ns5.non_empty_string_Def)
                ns5.Action_Dec.__bases__ = tuple(bases)

            ns5.non_empty_string_Def.__init__(self, **kw)
            if self.pyclass is not None: self.pyclass.__name__ = "Action_Dec_Holder"

    class MessageData_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration):
        schema = "http://www.ebxml.org/namespaces/messageHeader"
        literal = "MessageData"
        def __init__(self, **kw):
            ns = ns5.MessageData_Dec.schema
            TClist = [ns5.MessageId_Dec(minOccurs=1, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ns5.Timestamp_Dec(minOccurs=1, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ns5.RefToMessageId_Dec(minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ns5.TimeToLive_Dec(minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded"))]
            kw["pname"] = ("http://www.ebxml.org/namespaces/messageHeader","MessageData")
            kw["aname"] = "_MessageData"
            self.attribute_typecode_dict = {}
            ZSI.TCcompound.ComplexType.__init__(self, None, TClist, inorder=0, **kw)
            class Holder:
                __metaclass__ = pyclass_type
                typecode = self
                def __init__(self):
                    # pyclass
                    self._MessageId = None
                    self._Timestamp = None
                    self._RefToMessageId = None
                    self._TimeToLive = None
                    return
            Holder.__name__ = "MessageData_Holder"
            self.pyclass = Holder

    class MessageId_Dec(ElementDeclaration):
        literal = "MessageId"
        schema = "http://www.ebxml.org/namespaces/messageHeader"
        def __init__(self, **kw):
            kw["pname"] = ("http://www.ebxml.org/namespaces/messageHeader","MessageId")
            kw["aname"] = "_MessageId"
            if ns5.non_empty_string_Def not in ns5.MessageId_Dec.__bases__:
                bases = list(ns5.MessageId_Dec.__bases__)
                bases.insert(0, ns5.non_empty_string_Def)
                ns5.MessageId_Dec.__bases__ = tuple(bases)

            ns5.non_empty_string_Def.__init__(self, **kw)
            if self.pyclass is not None: self.pyclass.__name__ = "MessageId_Dec_Holder"

    class TimeToLive_Dec(ZSI.TCtimes.gDateTime, ElementDeclaration):
        literal = "TimeToLive"
        schema = "http://www.ebxml.org/namespaces/messageHeader"
        def __init__(self, **kw):
            kw["pname"] = ("http://www.ebxml.org/namespaces/messageHeader","TimeToLive")
            kw["aname"] = "_TimeToLive"
            class IHolder(tuple): typecode=self
            kw["pyclass"] = IHolder
            IHolder.__name__ = "_TimeToLive_immutable_holder"
            ZSI.TCtimes.gDateTime.__init__(self, **kw)

    class DuplicateElimination_Dec(ZSI.TC.AnyType, ElementDeclaration):
        literal = "DuplicateElimination"
        schema = "http://www.ebxml.org/namespaces/messageHeader"
        def __init__(self, **kw):
            kw["pname"] = ("http://www.ebxml.org/namespaces/messageHeader","DuplicateElimination")
            kw["aname"] = "_DuplicateElimination"
            ZSI.TC.AnyType.__init__(self, **kw)

    class SyncReply_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration):
        schema = "http://www.ebxml.org/namespaces/messageHeader"
        literal = "SyncReply"
        def __init__(self, **kw):
            ns = ns5.SyncReply_Dec.schema
            TClist = [ZSI.TC.AnyElement(aname="_any", minOccurs=0, maxOccurs="unbounded", nillable=False, processContents="lax")]
            kw["pname"] = ("http://www.ebxml.org/namespaces/messageHeader","SyncReply")
            kw["aname"] = "_SyncReply"
            self.attribute_typecode_dict = {}
            ZSI.TCcompound.ComplexType.__init__(self, None, TClist, inorder=0, **kw)
            # attribute handling code
            self.attribute_typecode_dict[("http://schemas.xmlsoap.org/soap/envelope/","actor")] = ZSI.TC.URI()
            self.attribute_typecode_dict[("http://www.ebxml.org/namespaces/messageHeader","id")] = ZSI.TC.AnyType()
            self.attribute_typecode_dict[("http://www.ebxml.org/namespaces/messageHeader","version")] = ns5.non_empty_string_Def(None)
            self.attribute_typecode_dict[("http://www.w3.org/2001/XMLSchema","anyAttribute")] = ZSI.TC.AnyElement()
            class Holder:
                __metaclass__ = pyclass_type
                typecode = self
                def __init__(self):
                    # pyclass
                    self._None = []
                    return
            Holder.__name__ = "SyncReply_Holder"
            self.pyclass = Holder

    class MessageOrder_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration):
        schema = "http://www.ebxml.org/namespaces/messageHeader"
        literal = "MessageOrder"
        def __init__(self, **kw):
            ns = ns5.MessageOrder_Dec.schema
            TClist = [ns5.SequenceNumber_Dec(minOccurs=1, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ZSI.TC.AnyElement(aname="_any", minOccurs=0, maxOccurs="unbounded", nillable=False, processContents="lax")]
            kw["pname"] = ("http://www.ebxml.org/namespaces/messageHeader","MessageOrder")
            kw["aname"] = "_MessageOrder"
            self.attribute_typecode_dict = {}
            ZSI.TCcompound.ComplexType.__init__(self, None, TClist, inorder=0, **kw)
            # attribute handling code
            self.attribute_typecode_dict[("http://www.ebxml.org/namespaces/messageHeader","id")] = ZSI.TC.AnyType()
            self.attribute_typecode_dict[("http://www.ebxml.org/namespaces/messageHeader","version")] = ns5.non_empty_string_Def(None)
            self.attribute_typecode_dict[("http://www.w3.org/2001/XMLSchema","anyAttribute")] = ZSI.TC.AnyElement()
            class Holder:
                __metaclass__ = pyclass_type
                typecode = self
                def __init__(self):
                    # pyclass
                    self._SequenceNumber = None
                    self._None = []
                    return
            Holder.__name__ = "MessageOrder_Holder"
            self.pyclass = Holder

    class SequenceNumber_Dec(ElementDeclaration):
        literal = "SequenceNumber"
        schema = "http://www.ebxml.org/namespaces/messageHeader"
        def __init__(self, **kw):
            kw["pname"] = ("http://www.ebxml.org/namespaces/messageHeader","SequenceNumber")
            kw["aname"] = "_SequenceNumber"
            if ns5.sequenceNumber_type_Def not in ns5.SequenceNumber_Dec.__bases__:
                bases = list(ns5.SequenceNumber_Dec.__bases__)
                bases.insert(0, ns5.sequenceNumber_type_Def)
                ns5.SequenceNumber_Dec.__bases__ = tuple(bases)

            ns5.sequenceNumber_type_Def.__init__(self, **kw)
            if self.pyclass is not None: self.pyclass.__name__ = "SequenceNumber_Dec_Holder"

    class AckRequested_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration):
        schema = "http://www.ebxml.org/namespaces/messageHeader"
        literal = "AckRequested"
        def __init__(self, **kw):
            ns = ns5.AckRequested_Dec.schema
            TClist = [ZSI.TC.AnyElement(aname="_any", minOccurs=0, maxOccurs="unbounded", nillable=False, processContents="lax")]
            kw["pname"] = ("http://www.ebxml.org/namespaces/messageHeader","AckRequested")
            kw["aname"] = "_AckRequested"
            self.attribute_typecode_dict = {}
            ZSI.TCcompound.ComplexType.__init__(self, None, TClist, inorder=0, **kw)
            # attribute handling code
            self.attribute_typecode_dict[("http://schemas.xmlsoap.org/soap/envelope/","actor")] = ZSI.TC.URI()
            self.attribute_typecode_dict[("http://www.ebxml.org/namespaces/messageHeader","signed")] = ZSI.TC.Boolean()
            self.attribute_typecode_dict[("http://www.ebxml.org/namespaces/messageHeader","id")] = ZSI.TC.AnyType()
            self.attribute_typecode_dict[("http://www.ebxml.org/namespaces/messageHeader","version")] = ns5.non_empty_string_Def(None)
            self.attribute_typecode_dict[("http://www.w3.org/2001/XMLSchema","anyAttribute")] = ZSI.TC.AnyElement()
            class Holder:
                __metaclass__ = pyclass_type
                typecode = self
                def __init__(self):
                    # pyclass
                    self._None = []
                    return
            Holder.__name__ = "AckRequested_Holder"
            self.pyclass = Holder

    class Acknowledgment_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration):
        schema = "http://www.ebxml.org/namespaces/messageHeader"
        literal = "Acknowledgment"
        def __init__(self, **kw):
            ns = ns5.Acknowledgment_Dec.schema
            TClist = [ns5.Timestamp_Dec(minOccurs=1, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ns5.RefToMessageId_Dec(minOccurs=1, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ns5.From_Dec(minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ns5.Reference_Dec(minOccurs=0, maxOccurs="unbounded", nillable=False, encoded=kw.get("encoded")), ZSI.TC.AnyElement(aname="_any", minOccurs=0, maxOccurs="unbounded", nillable=False, processContents="lax")]
            kw["pname"] = ("http://www.ebxml.org/namespaces/messageHeader","Acknowledgment")
            kw["aname"] = "_Acknowledgment"
            self.attribute_typecode_dict = {}
            ZSI.TCcompound.ComplexType.__init__(self, None, TClist, inorder=0, **kw)
            # attribute handling code
            self.attribute_typecode_dict[("http://schemas.xmlsoap.org/soap/envelope/","actor")] = ZSI.TC.URI()
            self.attribute_typecode_dict[("http://www.ebxml.org/namespaces/messageHeader","id")] = ZSI.TC.AnyType()
            self.attribute_typecode_dict[("http://www.ebxml.org/namespaces/messageHeader","version")] = ns5.non_empty_string_Def(None)
            self.attribute_typecode_dict[("http://www.w3.org/2001/XMLSchema","anyAttribute")] = ZSI.TC.AnyElement()
            class Holder:
                __metaclass__ = pyclass_type
                typecode = self
                def __init__(self):
                    # pyclass
                    self._Timestamp = None
                    self._RefToMessageId = None
                    self._From = None
                    self._Reference = None
                    self._None = []
                    return
            Holder.__name__ = "Acknowledgment_Holder"
            self.pyclass = Holder

    class ErrorList_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration):
        schema = "http://www.ebxml.org/namespaces/messageHeader"
        literal = "ErrorList"
        def __init__(self, **kw):
            ns = ns5.ErrorList_Dec.schema
            TClist = [ns5.Error_Dec(minOccurs=1, maxOccurs="unbounded", nillable=False, encoded=kw.get("encoded")), ZSI.TC.AnyElement(aname="_any", minOccurs=0, maxOccurs="unbounded", nillable=False, processContents="lax")]
            kw["pname"] = ("http://www.ebxml.org/namespaces/messageHeader","ErrorList")
            kw["aname"] = "_ErrorList"
            self.attribute_typecode_dict = {}
            ZSI.TCcompound.ComplexType.__init__(self, None, TClist, inorder=0, **kw)
            # attribute handling code
            self.attribute_typecode_dict[("http://www.ebxml.org/namespaces/messageHeader","highestSeverity")] = ns5.severity_type_Def(None)
            self.attribute_typecode_dict[("http://www.ebxml.org/namespaces/messageHeader","id")] = ZSI.TC.AnyType()
            self.attribute_typecode_dict[("http://www.ebxml.org/namespaces/messageHeader","version")] = ns5.non_empty_string_Def(None)
            self.attribute_typecode_dict[("http://www.w3.org/2001/XMLSchema","anyAttribute")] = ZSI.TC.AnyElement()
            class Holder:
                __metaclass__ = pyclass_type
                typecode = self
                def __init__(self):
                    # pyclass
                    self._Error = None
                    self._None = []
                    return
            Holder.__name__ = "ErrorList_Holder"
            self.pyclass = Holder

    class Error_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration):
        schema = "http://www.ebxml.org/namespaces/messageHeader"
        literal = "Error"
        def __init__(self, **kw):
            ns = ns5.Error_Dec.schema
            TClist = [ns5.Description_Dec(minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ZSI.TC.AnyElement(aname="_any", minOccurs=0, maxOccurs="unbounded", nillable=False, processContents="lax")]
            kw["pname"] = ("http://www.ebxml.org/namespaces/messageHeader","Error")
            kw["aname"] = "_Error"
            self.attribute_typecode_dict = {}
            ZSI.TCcompound.ComplexType.__init__(self, None, TClist, inorder=0, **kw)
            # attribute handling code
            self.attribute_typecode_dict[("http://www.ebxml.org/namespaces/messageHeader","id")] = ZSI.TC.AnyType()
            self.attribute_typecode_dict[("http://www.ebxml.org/namespaces/messageHeader","codeContext")] = ZSI.TC.URI()
            self.attribute_typecode_dict[("http://www.ebxml.org/namespaces/messageHeader","errorCode")] = ns5.non_empty_string_Def(None)
            self.attribute_typecode_dict[("http://www.ebxml.org/namespaces/messageHeader","severity")] = ns5.severity_type_Def(None)
            self.attribute_typecode_dict[("http://www.ebxml.org/namespaces/messageHeader","location")] = ns5.non_empty_string_Def(None)
            self.attribute_typecode_dict[("http://www.w3.org/2001/XMLSchema","anyAttribute")] = ZSI.TC.AnyElement()
            class Holder:
                __metaclass__ = pyclass_type
                typecode = self
                def __init__(self):
                    # pyclass
                    self._Description = None
                    self._None = []
                    return
            Holder.__name__ = "Error_Holder"
            self.pyclass = Holder

    class StatusResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration):
        schema = "http://www.ebxml.org/namespaces/messageHeader"
        literal = "StatusResponse"
        def __init__(self, **kw):
            ns = ns5.StatusResponse_Dec.schema
            TClist = [ns5.RefToMessageId_Dec(minOccurs=1, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ns5.Timestamp_Dec(minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ZSI.TC.AnyElement(aname="_any", minOccurs=0, maxOccurs="unbounded", nillable=False, processContents="lax")]
            kw["pname"] = ("http://www.ebxml.org/namespaces/messageHeader","StatusResponse")
            kw["aname"] = "_StatusResponse"
            self.attribute_typecode_dict = {}
            ZSI.TCcompound.ComplexType.__init__(self, None, TClist, inorder=0, **kw)
            # attribute handling code
            self.attribute_typecode_dict[("http://www.ebxml.org/namespaces/messageHeader","messageStatus")] = ns5.messageStatus_type_Def(None)
            self.attribute_typecode_dict[("http://www.ebxml.org/namespaces/messageHeader","id")] = ZSI.TC.AnyType()
            self.attribute_typecode_dict[("http://www.ebxml.org/namespaces/messageHeader","version")] = ns5.non_empty_string_Def(None)
            self.attribute_typecode_dict[("http://www.w3.org/2001/XMLSchema","anyAttribute")] = ZSI.TC.AnyElement()
            class Holder:
                __metaclass__ = pyclass_type
                typecode = self
                def __init__(self):
                    # pyclass
                    self._RefToMessageId = None
                    self._Timestamp = None
                    self._None = []
                    return
            Holder.__name__ = "StatusResponse_Holder"
            self.pyclass = Holder

    class StatusRequest_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration):
        schema = "http://www.ebxml.org/namespaces/messageHeader"
        literal = "StatusRequest"
        def __init__(self, **kw):
            ns = ns5.StatusRequest_Dec.schema
            TClist = [ns5.RefToMessageId_Dec(minOccurs=1, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ZSI.TC.AnyElement(aname="_any", minOccurs=0, maxOccurs="unbounded", nillable=False, processContents="lax")]
            kw["pname"] = ("http://www.ebxml.org/namespaces/messageHeader","StatusRequest")
            kw["aname"] = "_StatusRequest"
            self.attribute_typecode_dict = {}
            ZSI.TCcompound.ComplexType.__init__(self, None, TClist, inorder=0, **kw)
            # attribute handling code
            self.attribute_typecode_dict[("http://www.ebxml.org/namespaces/messageHeader","id")] = ZSI.TC.AnyType()
            self.attribute_typecode_dict[("http://www.ebxml.org/namespaces/messageHeader","version")] = ns5.non_empty_string_Def(None)
            self.attribute_typecode_dict[("http://www.w3.org/2001/XMLSchema","anyAttribute")] = ZSI.TC.AnyElement()
            class Holder:
                __metaclass__ = pyclass_type
                typecode = self
                def __init__(self):
                    # pyclass
                    self._RefToMessageId = None
                    self._None = []
                    return
            Holder.__name__ = "StatusRequest_Holder"
            self.pyclass = Holder

    class PartyId_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration):
        schema = "http://www.ebxml.org/namespaces/messageHeader"
        literal = "PartyId"
        def __init__(self, **kw):
            ns = ns5.PartyId_Dec.schema
            TClist = []
            kw["pname"] = ("http://www.ebxml.org/namespaces/messageHeader","PartyId")
            kw["aname"] = "_PartyId"
            self.attribute_typecode_dict = {}
            ZSI.TCcompound.ComplexType.__init__(self, None, TClist, inorder=0, **kw)
            class Holder:
                __metaclass__ = pyclass_type
                typecode = self
                def __init__(self):
                    # pyclass
                    return
            Holder.__name__ = "PartyId_Holder"
            self.pyclass = Holder

    class To_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration):
        schema = "http://www.ebxml.org/namespaces/messageHeader"
        literal = "To"
        def __init__(self, **kw):
            ns = ns5.To_Dec.schema
            TClist = [ns5.PartyId_Dec(minOccurs=1, maxOccurs="unbounded", nillable=False, encoded=kw.get("encoded")), ns5.non_empty_string_Def(pname=(ns,"Role"), aname="_Role", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded"))]
            kw["pname"] = ("http://www.ebxml.org/namespaces/messageHeader","To")
            kw["aname"] = "_To"
            self.attribute_typecode_dict = {}
            ZSI.TCcompound.ComplexType.__init__(self, None, TClist, inorder=0, **kw)
            class Holder:
                __metaclass__ = pyclass_type
                typecode = self
                def __init__(self):
                    # pyclass
                    self._PartyId = None
                    self._Role = None
                    return
            Holder.__name__ = "To_Holder"
            self.pyclass = Holder

    class From_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration):
        schema = "http://www.ebxml.org/namespaces/messageHeader"
        literal = "From"
        def __init__(self, **kw):
            ns = ns5.From_Dec.schema
            TClist = [ns5.PartyId_Dec(minOccurs=1, maxOccurs="unbounded", nillable=False, encoded=kw.get("encoded")), ns5.non_empty_string_Def(pname=(ns,"Role"), aname="_Role", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded"))]
            kw["pname"] = ("http://www.ebxml.org/namespaces/messageHeader","From")
            kw["aname"] = "_From"
            self.attribute_typecode_dict = {}
            ZSI.TCcompound.ComplexType.__init__(self, None, TClist, inorder=0, **kw)
            class Holder:
                __metaclass__ = pyclass_type
                typecode = self
                def __init__(self):
                    # pyclass
                    self._PartyId = None
                    self._Role = None
                    return
            Holder.__name__ = "From_Holder"
            self.pyclass = Holder

    class Description_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration):
        schema = "http://www.ebxml.org/namespaces/messageHeader"
        literal = "Description"
        def __init__(self, **kw):
            ns = ns5.Description_Dec.schema
            TClist = []
            kw["pname"] = ("http://www.ebxml.org/namespaces/messageHeader","Description")
            kw["aname"] = "_Description"
            self.attribute_typecode_dict = {}
            ZSI.TCcompound.ComplexType.__init__(self, None, TClist, inorder=0, **kw)
            class Holder:
                __metaclass__ = pyclass_type
                typecode = self
                def __init__(self):
                    # pyclass
                    return
            Holder.__name__ = "Description_Holder"
            self.pyclass = Holder

    class RefToMessageId_Dec(ElementDeclaration):
        literal = "RefToMessageId"
        schema = "http://www.ebxml.org/namespaces/messageHeader"
        def __init__(self, **kw):
            kw["pname"] = ("http://www.ebxml.org/namespaces/messageHeader","RefToMessageId")
            kw["aname"] = "_RefToMessageId"
            if ns5.non_empty_string_Def not in ns5.RefToMessageId_Dec.__bases__:
                bases = list(ns5.RefToMessageId_Dec.__bases__)
                bases.insert(0, ns5.non_empty_string_Def)
                ns5.RefToMessageId_Dec.__bases__ = tuple(bases)

            ns5.non_empty_string_Def.__init__(self, **kw)
            if self.pyclass is not None: self.pyclass.__name__ = "RefToMessageId_Dec_Holder"

    class Timestamp_Dec(ZSI.TC.String, ElementDeclaration):
        literal = "Timestamp"
        schema = "http://www.ebxml.org/namespaces/messageHeader"
        def __init__(self, **kw):
            kw["pname"] = ("http://www.ebxml.org/namespaces/messageHeader","Timestamp")
            kw["aname"] = "_Timestamp"
            class IHolder(str): typecode=self
            kw["pyclass"] = IHolder
            IHolder.__name__ = "_Timestamp_immutable_holder"
            ZSI.TC.String.__init__(self, **kw)

# end class ns5 (tns: http://www.ebxml.org/namespaces/messageHeader)

##############################
# targetNamespace
# http://schemas.xmlsoap.org/soap/envelope/
##############################

class ns8:
    targetNamespace = "http://schemas.xmlsoap.org/soap/envelope/"

    class Envelope_Def(ZSI.TCcompound.ComplexType, TypeDefinition):
        schema = "http://schemas.xmlsoap.org/soap/envelope/"
        type = (schema, "Envelope")
        def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw):
            ns = ns8.Envelope_Def.schema
            TClist = [ns8.Header_Dec(minOccurs=0, maxOccurs="unbounded", nillable=False, encoded=kw.get("encoded")), ns8.Body_Dec(minOccurs=1, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ZSI.TC.AnyElement(aname="_any", minOccurs=0, maxOccurs="unbounded", nillable=False, processContents="lax")]
            self.attribute_typecode_dict = attributes or {}
            if extend: TClist += ofwhat
            if restrict: TClist = ofwhat
            else:
                # attribute handling code
                self.attribute_typecode_dict[("http://www.w3.org/2001/XMLSchema","anyAttribute")] = ZSI.TC.AnyElement()
            ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw)
            class Holder:
                __metaclass__ = pyclass_type
                typecode = self
                def __init__(self):
                    # pyclass
                    self._Header = None
                    self._Body = None
                    self._None = []
                    return
            Holder.__name__ = "Envelope_Holder"
            self.pyclass = Holder

    class Header_Def(ZSI.TCcompound.ComplexType, TypeDefinition):
        schema = "http://schemas.xmlsoap.org/soap/envelope/"
        type = (schema, "Header")
        def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw):
            ns = ns8.Header_Def.schema
            TClist = [ZSI.TC.AnyElement(aname="_any", minOccurs=0, maxOccurs="unbounded", nillable=False, processContents="lax")]
            self.attribute_typecode_dict = attributes or {}
            if extend: TClist += ofwhat
            if restrict: TClist = ofwhat
            else:
                # attribute handling code
                self.attribute_typecode_dict[("http://www.w3.org/2001/XMLSchema","anyAttribute")] = ZSI.TC.AnyElement()
            ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw)
            class Holder:
                __metaclass__ = pyclass_type
                typecode = self
                def __init__(self):
                    # pyclass
                    self._None = []
                    return
            Holder.__name__ = "Header_Holder"
            self.pyclass = Holder

    class Body_Def(ZSI.TCcompound.ComplexType, TypeDefinition):
        schema = "http://schemas.xmlsoap.org/soap/envelope/"
        type = (schema, "Body")
        def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw):
            ns = ns8.Body_Def.schema
            TClist = [ZSI.TC.AnyElement(aname="_any", minOccurs=0, maxOccurs="unbounded", nillable=False, processContents="lax")]
            self.attribute_typecode_dict = attributes or {}
            if extend: TClist += ofwhat
            if restrict: TClist = ofwhat
            else:
                # attribute handling code
                self.attribute_typecode_dict[("http://www.w3.org/2001/XMLSchema","anyAttribute")] = ZSI.TC.AnyElement()
            ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw)
            class Holder:
                __metaclass__ = pyclass_type
                typecode = self
                def __init__(self):
                    # pyclass
                    self._None = []
                    return
            Holder.__name__ = "Body_Holder"
            self.pyclass = Holder

    class encodingStyle_Def(ZSI.TC.List, TypeDefinition):
        itemType = (u'http://www.w3.org/2001/XMLSchema', u'anyURI')
        schema = "http://schemas.xmlsoap.org/soap/envelope/"
        type = (schema, "encodingStyle")
        def __init__(self, pname, **kw):
            ZSI.TC.List.__init__(self, pname, **kw)

    class Fault_Def(ZSI.TCcompound.ComplexType, TypeDefinition):
        schema = "http://schemas.xmlsoap.org/soap/envelope/"
        type = (schema, "Fault")
        def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw):
            ns = ns8.Fault_Def.schema
            TClist = [ZSI.TC.QName(pname="faultcode", aname="_faultcode", minOccurs=1, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ZSI.TC.String(pname="faultstring", aname="_faultstring", minOccurs=1, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ZSI.TC.URI(pname="faultactor", aname="_faultactor", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ns8.detail_Def(pname="detail", aname="_detail", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded"))]
            self.attribute_typecode_dict = attributes or {}
            if extend: TClist += ofwhat
            if restrict: TClist = ofwhat
            ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw)
            class Holder:
                __metaclass__ = pyclass_type
                typecode = self
                def __init__(self):
                    # pyclass
                    self._faultcode = None
                    self._faultstring = None
                    self._faultactor = None
                    self._detail = None
                    return
            Holder.__name__ = "Fault_Holder"
            self.pyclass = Holder

    class detail_Def(ZSI.TCcompound.ComplexType, TypeDefinition):
        schema = "http://schemas.xmlsoap.org/soap/envelope/"
        type = (schema, "detail")
        def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw):
            ns = ns8.detail_Def.schema
            TClist = [ZSI.TC.AnyElement(aname="_any", minOccurs=0, maxOccurs="unbounded", nillable=False, processContents="lax")]
            self.attribute_typecode_dict = attributes or {}
            if extend: TClist += ofwhat
            if restrict: TClist = ofwhat
            else:
                # attribute handling code
                self.attribute_typecode_dict[("http://www.w3.org/2001/XMLSchema","anyAttribute")] = ZSI.TC.AnyElement()
            ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw)
            class Holder:
                __metaclass__ = pyclass_type
                typecode = self
                def __init__(self):
                    # pyclass
                    self._None = []
                    return
            Holder.__name__ = "detail_Holder"
            self.pyclass = Holder

    class Envelope_Dec(ElementDeclaration):
        literal = "Envelope"
        schema = "http://schemas.xmlsoap.org/soap/envelope/"
        def __init__(self, **kw):
            kw["pname"] = ("http://schemas.xmlsoap.org/soap/envelope/","Envelope")
            kw["aname"] = "_Envelope"
            if ns8.Envelope_Def not in ns8.Envelope_Dec.__bases__:
                bases = list(ns8.Envelope_Dec.__bases__)
                bases.insert(0, ns8.Envelope_Def)
                ns8.Envelope_Dec.__bases__ = tuple(bases)

            ns8.Envelope_Def.__init__(self, **kw)
            if self.pyclass is not None: self.pyclass.__name__ = "Envelope_Dec_Holder"

    class Header_Dec(ElementDeclaration):
        literal = "Header"
        schema = "http://schemas.xmlsoap.org/soap/envelope/"
        def __init__(self, **kw):
            kw["pname"] = ("http://schemas.xmlsoap.org/soap/envelope/","Header")
            kw["aname"] = "_Header"
            if ns8.Header_Def not in ns8.Header_Dec.__bases__:
                bases = list(ns8.Header_Dec.__bases__)
                bases.insert(0, ns8.Header_Def)
                ns8.Header_Dec.__bases__ = tuple(bases)

            ns8.Header_Def.__init__(self, **kw)
            if self.pyclass is not None: self.pyclass.__name__ = "Header_Dec_Holder"

    class Body_Dec(ElementDeclaration):
        literal = "Body"
        schema = "http://schemas.xmlsoap.org/soap/envelope/"
        def __init__(self, **kw):
            kw["pname"] = ("http://schemas.xmlsoap.org/soap/envelope/","Body")
            kw["aname"] = "_Body"
            if ns8.Body_Def not in ns8.Body_Dec.__bases__:
                bases = list(ns8.Body_Dec.__bases__)
                bases.insert(0, ns8.Body_Def)
                ns8.Body_Dec.__bases__ = tuple(bases)

            ns8.Body_Def.__init__(self, **kw)
            if self.pyclass is not None: self.pyclass.__name__ = "Body_Dec_Holder"

    class Fault_Dec(ElementDeclaration):
        literal = "Fault"
        schema = "http://schemas.xmlsoap.org/soap/envelope/"
        def __init__(self, **kw):
            kw["pname"] = ("http://schemas.xmlsoap.org/soap/envelope/","Fault")
            kw["aname"] = "_Fault"
            if ns8.Fault_Def not in ns8.Fault_Dec.__bases__:
                bases = list(ns8.Fault_Dec.__bases__)
                bases.insert(0, ns8.Fault_Def)
                ns8.Fault_Dec.__bases__ = tuple(bases)

            ns8.Fault_Def.__init__(self, **kw)
            if self.pyclass is not None: self.pyclass.__name__ = "Fault_Dec_Holder"

# end class ns8 (tns: http://schemas.xmlsoap.org/soap/envelope/)

##############################
# targetNamespace
# http://www.w3.org/XML/1998/namespace
##############################

class ns9:
    targetNamespace = "http://www.w3.org/XML/1998/namespace"

# end class ns9 (tns: http://www.w3.org/XML/1998/namespace)

##############################
# targetNamespace
# http://www.w3.org/1999/xlink
##############################

class ns7:
    targetNamespace = "http://www.w3.org/1999/xlink"

    class root_Dec(ZSI.TC.AnyType, ElementDeclaration):
        literal = "root"
        schema = "http://www.w3.org/1999/xlink"
        def __init__(self, **kw):
            kw["pname"] = ("http://www.w3.org/1999/xlink","root")
            kw["aname"] = "_root"
            ZSI.TC.AnyType.__init__(self, **kw)

# end class ns7 (tns: http://www.w3.org/1999/xlink)
