################################################## 
# OpcXmlDaSrv_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://opcfoundation.org/webservices/XMLDA/1.0/
##############################

class ns4:
    targetNamespace = "http://opcfoundation.org/webservices/XMLDA/1.0/"

    class ItemIdentifier_Def(ZSI.TCcompound.ComplexType, TypeDefinition):
        schema = "http://opcfoundation.org/webservices/XMLDA/1.0/"
        type = (schema, "ItemIdentifier")
        def __init__(self, pname, **kw):
            ns = ns4.ItemIdentifier_Def.schema
            TClist = []
            self.attribute_typecode_dict = {}
            ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw)
            # attribute handling code
            self.attribute_typecode_dict["ItemPath"] = ZSI.TC.String()
            self.attribute_typecode_dict["ItemName"] = ZSI.TC.String()
            class Holder:
                __metaclass__ = pyclass_type
                typecode = self
                def __init__(self):
                    # pyclass
                    return
            Holder.__name__ = "ItemIdentifier_Holder"
            self.pyclass = Holder

    class ReplyBase_Def(ZSI.TCcompound.ComplexType, TypeDefinition):
        schema = "http://opcfoundation.org/webservices/XMLDA/1.0/"
        type = (schema, "ReplyBase")
        def __init__(self, pname, **kw):
            ns = ns4.ReplyBase_Def.schema
            TClist = []
            self.attribute_typecode_dict = {}
            ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw)
            # attribute handling code
            self.attribute_typecode_dict["RcvTime"] = ZSI.TCtimes.gDateTime()
            self.attribute_typecode_dict["ReplyTime"] = ZSI.TCtimes.gDateTime()
            self.attribute_typecode_dict["ClientRequestHandle"] = ZSI.TC.String()
            self.attribute_typecode_dict["RevisedLocaleID"] = ZSI.TC.String()
            self.attribute_typecode_dict["ServerState"] = ns4.serverState_Def(None)
            class Holder:
                __metaclass__ = pyclass_type
                typecode = self
                def __init__(self):
                    # pyclass
                    return
            Holder.__name__ = "ReplyBase_Holder"
            self.pyclass = Holder

    class serverState_Def(ZSI.TC.String, TypeDefinition):
        schema = "http://opcfoundation.org/webservices/XMLDA/1.0/"
        type = (schema, "serverState")
        def __init__(self, pname, **kw):
            ZSI.TC.String.__init__(self, pname, pyclass=None, **kw)
            class Holder(str):
                typecode = self
            self.pyclass = Holder

    class PropertyReplyList_Def(ZSI.TCcompound.ComplexType, TypeDefinition):
        schema = "http://opcfoundation.org/webservices/XMLDA/1.0/"
        type = (schema, "PropertyReplyList")
        def __init__(self, pname, **kw):
            ns = ns4.PropertyReplyList_Def.schema
            TClist = [ns4.ItemProperty_Def(pname=(ns,"Properties"), aname="_Properties", minOccurs=0, maxOccurs="unbounded", nillable=False, encoded=kw.get("encoded"))]
            self.attribute_typecode_dict = {}
            ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw)
            # attribute handling code
            self.attribute_typecode_dict["ItemPath"] = ZSI.TC.String()
            self.attribute_typecode_dict["ItemName"] = ZSI.TC.String()
            self.attribute_typecode_dict["ResultID"] = ZSI.TC.QName()
            class Holder:
                __metaclass__ = pyclass_type
                typecode = self
                def __init__(self):
                    # pyclass
                    self._Properties = []
                    return
            Holder.__name__ = "PropertyReplyList_Holder"
            self.pyclass = Holder

    class ItemProperty_Def(ZSI.TCcompound.ComplexType, TypeDefinition):
        schema = "http://opcfoundation.org/webservices/XMLDA/1.0/"
        type = (schema, "ItemProperty")
        def __init__(self, pname, **kw):
            ns = ns4.ItemProperty_Def.schema
            TClist = [ZSI.TC.AnyType(pname=(ns,"Value"), aname="_Value", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded"))]
            self.attribute_typecode_dict = {}
            ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw)
            # attribute handling code
            self.attribute_typecode_dict["Name"] = ZSI.TC.QName()
            self.attribute_typecode_dict["Description"] = ZSI.TC.String()
            self.attribute_typecode_dict["ItemPath"] = ZSI.TC.String()
            self.attribute_typecode_dict["ItemName"] = ZSI.TC.String()
            self.attribute_typecode_dict["ResultID"] = ZSI.TC.QName()
            class Holder:
                __metaclass__ = pyclass_type
                typecode = self
                def __init__(self):
                    # pyclass
                    self._Value = None
                    return
            Holder.__name__ = "ItemProperty_Holder"
            self.pyclass = Holder

    class OPCError_Def(ZSI.TCcompound.ComplexType, TypeDefinition):
        schema = "http://opcfoundation.org/webservices/XMLDA/1.0/"
        type = (schema, "OPCError")
        def __init__(self, pname, **kw):
            ns = ns4.OPCError_Def.schema
            TClist = [ZSI.TC.String(pname=(ns,"Text"), aname="_Text", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded"))]
            self.attribute_typecode_dict = {}
            ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw)
            # attribute handling code
            self.attribute_typecode_dict["ID"] = ZSI.TC.QName()
            class Holder:
                __metaclass__ = pyclass_type
                typecode = self
                def __init__(self):
                    # pyclass
                    self._Text = None
                    return
            Holder.__name__ = "OPCError_Holder"
            self.pyclass = Holder

    class ArrayOfDouble_Def(ZSI.TCcompound.ComplexType, TypeDefinition):
        schema = "http://opcfoundation.org/webservices/XMLDA/1.0/"
        type = (schema, "ArrayOfDouble")
        def __init__(self, pname, **kw):
            ns = ns4.ArrayOfDouble_Def.schema
            TClist = [ZSI.TCnumbers.FPdouble(pname=(ns,"double"), aname="_double", minOccurs=0, maxOccurs="unbounded", nillable=False, encoded=kw.get("encoded"))]
            self.attribute_typecode_dict = {}
            ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw)
            class Holder:
                __metaclass__ = pyclass_type
                typecode = self
                def __init__(self):
                    # pyclass
                    self._double = []
                    return
            Holder.__name__ = "ArrayOfDouble_Holder"
            self.pyclass = Holder

    class ArrayOfUnsignedShort_Def(ZSI.TCcompound.ComplexType, TypeDefinition):
        schema = "http://opcfoundation.org/webservices/XMLDA/1.0/"
        type = (schema, "ArrayOfUnsignedShort")
        def __init__(self, pname, **kw):
            ns = ns4.ArrayOfUnsignedShort_Def.schema
            TClist = [ZSI.TCnumbers.IunsignedShort(pname=(ns,"unsignedShort"), aname="_unsignedShort", minOccurs=0, maxOccurs="unbounded", nillable=False, encoded=kw.get("encoded"))]
            self.attribute_typecode_dict = {}
            ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw)
            class Holder:
                __metaclass__ = pyclass_type
                typecode = self
                def __init__(self):
                    # pyclass
                    self._unsignedShort = []
                    return
            Holder.__name__ = "ArrayOfUnsignedShort_Holder"
            self.pyclass = Holder

    class ArrayOfDateTime_Def(ZSI.TCcompound.ComplexType, TypeDefinition):
        schema = "http://opcfoundation.org/webservices/XMLDA/1.0/"
        type = (schema, "ArrayOfDateTime")
        def __init__(self, pname, **kw):
            ns = ns4.ArrayOfDateTime_Def.schema
            TClist = [ZSI.TCtimes.gDateTime(pname=(ns,"dateTime"), aname="_dateTime", minOccurs=0, maxOccurs="unbounded", nillable=False, encoded=kw.get("encoded"))]
            self.attribute_typecode_dict = {}
            ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw)
            class Holder:
                __metaclass__ = pyclass_type
                typecode = self
                def __init__(self):
                    # pyclass
                    self._dateTime = []
                    return
            Holder.__name__ = "ArrayOfDateTime_Holder"
            self.pyclass = Holder

    class ArrayOfAnyType_Def(ZSI.TCcompound.ComplexType, TypeDefinition):
        schema = "http://opcfoundation.org/webservices/XMLDA/1.0/"
        type = (schema, "ArrayOfAnyType")
        def __init__(self, pname, **kw):
            ns = ns4.ArrayOfAnyType_Def.schema
            TClist = [ZSI.TC.AnyType(pname=(ns,"anyType"), aname="_anyType", minOccurs=0, maxOccurs="unbounded", nillable=True, encoded=kw.get("encoded"))]
            self.attribute_typecode_dict = {}
            ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw)
            class Holder:
                __metaclass__ = pyclass_type
                typecode = self
                def __init__(self):
                    # pyclass
                    self._anyType = []
                    return
            Holder.__name__ = "ArrayOfAnyType_Holder"
            self.pyclass = Holder

    class ArrayOfDecimal_Def(ZSI.TCcompound.ComplexType, TypeDefinition):
        schema = "http://opcfoundation.org/webservices/XMLDA/1.0/"
        type = (schema, "ArrayOfDecimal")
        def __init__(self, pname, **kw):
            ns = ns4.ArrayOfDecimal_Def.schema
            TClist = [ZSI.TC.Decimal(pname=(ns,"decimal"), aname="_decimal", minOccurs=0, maxOccurs="unbounded", nillable=False, encoded=kw.get("encoded"))]
            self.attribute_typecode_dict = {}
            ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw)
            class Holder:
                __metaclass__ = pyclass_type
                typecode = self
                def __init__(self):
                    # pyclass
                    self._decimal = []
                    return
            Holder.__name__ = "ArrayOfDecimal_Holder"
            self.pyclass = Holder

    class ArrayOfByte_Def(ZSI.TCcompound.ComplexType, TypeDefinition):
        schema = "http://opcfoundation.org/webservices/XMLDA/1.0/"
        type = (schema, "ArrayOfByte")
        def __init__(self, pname, **kw):
            ns = ns4.ArrayOfByte_Def.schema
            TClist = [ZSI.TCnumbers.Ibyte(pname=(ns,"byte"), aname="_byte", minOccurs=0, maxOccurs="unbounded", nillable=False, encoded=kw.get("encoded"))]
            self.attribute_typecode_dict = {}
            ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw)
            class Holder:
                __metaclass__ = pyclass_type
                typecode = self
                def __init__(self):
                    # pyclass
                    self._byte = []
                    return
            Holder.__name__ = "ArrayOfByte_Holder"
            self.pyclass = Holder

    class ArrayOfShort_Def(ZSI.TCcompound.ComplexType, TypeDefinition):
        schema = "http://opcfoundation.org/webservices/XMLDA/1.0/"
        type = (schema, "ArrayOfShort")
        def __init__(self, pname, **kw):
            ns = ns4.ArrayOfShort_Def.schema
            TClist = [ZSI.TCnumbers.Ishort(pname=(ns,"short"), aname="_short", minOccurs=0, maxOccurs="unbounded", nillable=False, encoded=kw.get("encoded"))]
            self.attribute_typecode_dict = {}
            ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw)
            class Holder:
                __metaclass__ = pyclass_type
                typecode = self
                def __init__(self):
                    # pyclass
                    self._short = []
                    return
            Holder.__name__ = "ArrayOfShort_Holder"
            self.pyclass = Holder

    class ArrayOfBoolean_Def(ZSI.TCcompound.ComplexType, TypeDefinition):
        schema = "http://opcfoundation.org/webservices/XMLDA/1.0/"
        type = (schema, "ArrayOfBoolean")
        def __init__(self, pname, **kw):
            ns = ns4.ArrayOfBoolean_Def.schema
            TClist = [ZSI.TC.Boolean(pname=(ns,"boolean"), aname="_boolean", minOccurs=0, maxOccurs="unbounded", nillable=False, encoded=kw.get("encoded"))]
            self.attribute_typecode_dict = {}
            ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw)
            class Holder:
                __metaclass__ = pyclass_type
                typecode = self
                def __init__(self):
                    # pyclass
                    self._boolean = []
                    return
            Holder.__name__ = "ArrayOfBoolean_Holder"
            self.pyclass = Holder

    class ArrayOfString_Def(ZSI.TCcompound.ComplexType, TypeDefinition):
        schema = "http://opcfoundation.org/webservices/XMLDA/1.0/"
        type = (schema, "ArrayOfString")
        def __init__(self, pname, **kw):
            ns = ns4.ArrayOfString_Def.schema
            TClist = [ZSI.TC.String(pname=(ns,"string"), aname="_string", minOccurs=0, maxOccurs="unbounded", nillable=True, encoded=kw.get("encoded"))]
            self.attribute_typecode_dict = {}
            ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw)
            class Holder:
                __metaclass__ = pyclass_type
                typecode = self
                def __init__(self):
                    # pyclass
                    self._string = []
                    return
            Holder.__name__ = "ArrayOfString_Holder"
            self.pyclass = Holder

    class ArrayOfFloat_Def(ZSI.TCcompound.ComplexType, TypeDefinition):
        schema = "http://opcfoundation.org/webservices/XMLDA/1.0/"
        type = (schema, "ArrayOfFloat")
        def __init__(self, pname, **kw):
            ns = ns4.ArrayOfFloat_Def.schema
            TClist = [ZSI.TCnumbers.FPfloat(pname=(ns,"float"), aname="_float", minOccurs=0, maxOccurs="unbounded", nillable=False, encoded=kw.get("encoded"))]
            self.attribute_typecode_dict = {}
            ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw)
            class Holder:
                __metaclass__ = pyclass_type
                typecode = self
                def __init__(self):
                    # pyclass
                    self._float = []
                    return
            Holder.__name__ = "ArrayOfFloat_Holder"
            self.pyclass = Holder

    class ArrayOfInt_Def(ZSI.TCcompound.ComplexType, TypeDefinition):
        schema = "http://opcfoundation.org/webservices/XMLDA/1.0/"
        type = (schema, "ArrayOfInt")
        def __init__(self, pname, **kw):
            ns = ns4.ArrayOfInt_Def.schema
            TClist = [ZSI.TCnumbers.Iint(pname=(ns,"int"), aname="_int", minOccurs=0, maxOccurs="unbounded", nillable=False, encoded=kw.get("encoded"))]
            self.attribute_typecode_dict = {}
            ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw)
            class Holder:
                __metaclass__ = pyclass_type
                typecode = self
                def __init__(self):
                    # pyclass
                    self._int = []
                    return
            Holder.__name__ = "ArrayOfInt_Holder"
            self.pyclass = Holder

    class ArrayOfUnsignedInt_Def(ZSI.TCcompound.ComplexType, TypeDefinition):
        schema = "http://opcfoundation.org/webservices/XMLDA/1.0/"
        type = (schema, "ArrayOfUnsignedInt")
        def __init__(self, pname, **kw):
            ns = ns4.ArrayOfUnsignedInt_Def.schema
            TClist = [ZSI.TCnumbers.IunsignedInt(pname=(ns,"unsignedInt"), aname="_unsignedInt", minOccurs=0, maxOccurs="unbounded", nillable=False, encoded=kw.get("encoded"))]
            self.attribute_typecode_dict = {}
            ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw)
            class Holder:
                __metaclass__ = pyclass_type
                typecode = self
                def __init__(self):
                    # pyclass
                    self._unsignedInt = []
                    return
            Holder.__name__ = "ArrayOfUnsignedInt_Holder"
            self.pyclass = Holder

    class ArrayOfLong_Def(ZSI.TCcompound.ComplexType, TypeDefinition):
        schema = "http://opcfoundation.org/webservices/XMLDA/1.0/"
        type = (schema, "ArrayOfLong")
        def __init__(self, pname, **kw):
            ns = ns4.ArrayOfLong_Def.schema
            TClist = [ZSI.TCnumbers.Ilong(pname=(ns,"long"), aname="_long", minOccurs=0, maxOccurs="unbounded", nillable=False, encoded=kw.get("encoded"))]
            self.attribute_typecode_dict = {}
            ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw)
            class Holder:
                __metaclass__ = pyclass_type
                typecode = self
                def __init__(self):
                    # pyclass
                    self._long = []
                    return
            Holder.__name__ = "ArrayOfLong_Holder"
            self.pyclass = Holder

    class ArrayOfUnsignedLong_Def(ZSI.TCcompound.ComplexType, TypeDefinition):
        schema = "http://opcfoundation.org/webservices/XMLDA/1.0/"
        type = (schema, "ArrayOfUnsignedLong")
        def __init__(self, pname, **kw):
            ns = ns4.ArrayOfUnsignedLong_Def.schema
            TClist = [ZSI.TCnumbers.IunsignedLong(pname=(ns,"unsignedLong"), aname="_unsignedLong", minOccurs=0, maxOccurs="unbounded", nillable=False, encoded=kw.get("encoded"))]
            self.attribute_typecode_dict = {}
            ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw)
            class Holder:
                __metaclass__ = pyclass_type
                typecode = self
                def __init__(self):
                    # pyclass
                    self._unsignedLong = []
                    return
            Holder.__name__ = "ArrayOfUnsignedLong_Holder"
            self.pyclass = Holder

    class RequestOptions_Def(ZSI.TCcompound.ComplexType, TypeDefinition):
        schema = "http://opcfoundation.org/webservices/XMLDA/1.0/"
        type = (schema, "RequestOptions")
        def __init__(self, pname, **kw):
            ns = ns4.RequestOptions_Def.schema
            TClist = []
            self.attribute_typecode_dict = {}
            ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw)
            # attribute handling code
            self.attribute_typecode_dict["ReturnErrorText"] = ZSI.TC.Boolean()
            self.attribute_typecode_dict["ReturnDiagnosticInfo"] = ZSI.TC.Boolean()
            self.attribute_typecode_dict["ReturnItemTime"] = ZSI.TC.Boolean()
            self.attribute_typecode_dict["ReturnItemPath"] = ZSI.TC.Boolean()
            self.attribute_typecode_dict["ReturnItemName"] = ZSI.TC.Boolean()
            self.attribute_typecode_dict["RequestDeadline"] = ZSI.TCtimes.gDateTime()
            self.attribute_typecode_dict["ClientRequestHandle"] = ZSI.TC.String()
            self.attribute_typecode_dict["LocaleID"] = ZSI.TC.String()
            class Holder:
                __metaclass__ = pyclass_type
                typecode = self
                def __init__(self):
                    # pyclass
                    return
            Holder.__name__ = "RequestOptions_Holder"
            self.pyclass = Holder

    class SubscribeRequestItemList_Def(ZSI.TCcompound.ComplexType, TypeDefinition):
        schema = "http://opcfoundation.org/webservices/XMLDA/1.0/"
        type = (schema, "SubscribeRequestItemList")
        def __init__(self, pname, **kw):
            ns = ns4.SubscribeRequestItemList_Def.schema
            TClist = [ns4.SubscribeRequestItem_Def(pname=(ns,"Items"), aname="_Items", minOccurs=0, maxOccurs="unbounded", nillable=False, encoded=kw.get("encoded"))]
            self.attribute_typecode_dict = {}
            ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw)
            # attribute handling code
            self.attribute_typecode_dict["ItemPath"] = ZSI.TC.String()
            self.attribute_typecode_dict["ReqType"] = ZSI.TC.QName()
            self.attribute_typecode_dict["Deadband"] = ZSI.TCnumbers.FPfloat()
            self.attribute_typecode_dict["RequestedSamplingRate"] = ZSI.TCnumbers.Iint()
            self.attribute_typecode_dict["EnableBuffering"] = ZSI.TC.Boolean()
            class Holder:
                __metaclass__ = pyclass_type
                typecode = self
                def __init__(self):
                    # pyclass
                    self._Items = []
                    return
            Holder.__name__ = "SubscribeRequestItemList_Holder"
            self.pyclass = Holder

    class SubscribeRequestItem_Def(ZSI.TCcompound.ComplexType, TypeDefinition):
        schema = "http://opcfoundation.org/webservices/XMLDA/1.0/"
        type = (schema, "SubscribeRequestItem")
        def __init__(self, pname, **kw):
            ns = ns4.SubscribeRequestItem_Def.schema
            TClist = []
            self.attribute_typecode_dict = {}
            ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw)
            # attribute handling code
            self.attribute_typecode_dict["ItemPath"] = ZSI.TC.String()
            self.attribute_typecode_dict["ReqType"] = ZSI.TC.QName()
            self.attribute_typecode_dict["ItemName"] = ZSI.TC.String()
            self.attribute_typecode_dict["ClientItemHandle"] = ZSI.TC.String()
            self.attribute_typecode_dict["Deadband"] = ZSI.TCnumbers.FPfloat()
            self.attribute_typecode_dict["RequestedSamplingRate"] = ZSI.TCnumbers.Iint()
            self.attribute_typecode_dict["EnableBuffering"] = ZSI.TC.Boolean()
            class Holder:
                __metaclass__ = pyclass_type
                typecode = self
                def __init__(self):
                    # pyclass
                    return
            Holder.__name__ = "SubscribeRequestItem_Holder"
            self.pyclass = Holder

    class SubscribeReplyItemList_Def(ZSI.TCcompound.ComplexType, TypeDefinition):
        schema = "http://opcfoundation.org/webservices/XMLDA/1.0/"
        type = (schema, "SubscribeReplyItemList")
        def __init__(self, pname, **kw):
            ns = ns4.SubscribeReplyItemList_Def.schema
            TClist = [ns4.SubscribeItemValue_Def(pname=(ns,"Items"), aname="_Items", minOccurs=0, maxOccurs="unbounded", nillable=False, encoded=kw.get("encoded"))]
            self.attribute_typecode_dict = {}
            ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw)
            # attribute handling code
            self.attribute_typecode_dict["RevisedSamplingRate"] = ZSI.TCnumbers.Iint()
            class Holder:
                __metaclass__ = pyclass_type
                typecode = self
                def __init__(self):
                    # pyclass
                    self._Items = []
                    return
            Holder.__name__ = "SubscribeReplyItemList_Holder"
            self.pyclass = Holder

    class SubscribeItemValue_Def(ZSI.TCcompound.ComplexType, TypeDefinition):
        schema = "http://opcfoundation.org/webservices/XMLDA/1.0/"
        type = (schema, "SubscribeItemValue")
        def __init__(self, pname, **kw):
            ns = ns4.SubscribeItemValue_Def.schema
            TClist = [ns4.ItemValue_Def(pname=(ns,"ItemValue"), aname="_ItemValue", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded"))]
            self.attribute_typecode_dict = {}
            ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw)
            # attribute handling code
            self.attribute_typecode_dict["RevisedSamplingRate"] = ZSI.TCnumbers.Iint()
            class Holder:
                __metaclass__ = pyclass_type
                typecode = self
                def __init__(self):
                    # pyclass
                    self._ItemValue = None
                    return
            Holder.__name__ = "SubscribeItemValue_Holder"
            self.pyclass = Holder

    class ItemValue_Def(ZSI.TCcompound.ComplexType, TypeDefinition):
        schema = "http://opcfoundation.org/webservices/XMLDA/1.0/"
        type = (schema, "ItemValue")
        def __init__(self, pname, **kw):
            ns = ns4.ItemValue_Def.schema
            TClist = [ZSI.TC.String(pname=(ns,"DiagnosticInfo"), aname="_DiagnosticInfo", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ZSI.TC.AnyType(pname=(ns,"Value"), aname="_Value", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ns4.OPCQuality_Def(pname=(ns,"Quality"), aname="_Quality", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded"))]
            self.attribute_typecode_dict = {}
            ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw)
            # attribute handling code
            self.attribute_typecode_dict["ValueTypeQualifier"] = ZSI.TC.QName()
            self.attribute_typecode_dict["ItemPath"] = ZSI.TC.String()
            self.attribute_typecode_dict["ItemName"] = ZSI.TC.String()
            self.attribute_typecode_dict["ClientItemHandle"] = ZSI.TC.String()
            self.attribute_typecode_dict["Timestamp"] = ZSI.TCtimes.gDateTime()
            self.attribute_typecode_dict["ResultID"] = ZSI.TC.QName()
            class Holder:
                __metaclass__ = pyclass_type
                typecode = self
                def __init__(self):
                    # pyclass
                    self._DiagnosticInfo = None
                    self._Value = None
                    self._Quality = None
                    return
            Holder.__name__ = "ItemValue_Holder"
            self.pyclass = Holder

    class OPCQuality_Def(ZSI.TCcompound.ComplexType, TypeDefinition):
        schema = "http://opcfoundation.org/webservices/XMLDA/1.0/"
        type = (schema, "OPCQuality")
        def __init__(self, pname, **kw):
            ns = ns4.OPCQuality_Def.schema
            TClist = []
            self.attribute_typecode_dict = {}
            ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw)
            # attribute handling code
            self.attribute_typecode_dict["QualityField"] = ns4.qualityBits_Def(None)
            self.attribute_typecode_dict["LimitField"] = ns4.limitBits_Def(None)
            self.attribute_typecode_dict["VendorField"] = ZSI.TCnumbers.IunsignedByte()
            class Holder:
                __metaclass__ = pyclass_type
                typecode = self
                def __init__(self):
                    # pyclass
                    return
            Holder.__name__ = "OPCQuality_Holder"
            self.pyclass = Holder

    class qualityBits_Def(ZSI.TC.String, TypeDefinition):
        schema = "http://opcfoundation.org/webservices/XMLDA/1.0/"
        type = (schema, "qualityBits")
        def __init__(self, pname, **kw):
            ZSI.TC.String.__init__(self, pname, pyclass=None, **kw)
            class Holder(str):
                typecode = self
            self.pyclass = Holder

    class limitBits_Def(ZSI.TC.String, TypeDefinition):
        schema = "http://opcfoundation.org/webservices/XMLDA/1.0/"
        type = (schema, "limitBits")
        def __init__(self, pname, **kw):
            ZSI.TC.String.__init__(self, pname, pyclass=None, **kw)
            class Holder(str):
                typecode = self
            self.pyclass = Holder

    class SubscribePolledRefreshReplyItemList_Def(ZSI.TCcompound.ComplexType, TypeDefinition):
        schema = "http://opcfoundation.org/webservices/XMLDA/1.0/"
        type = (schema, "SubscribePolledRefreshReplyItemList")
        def __init__(self, pname, **kw):
            ns = ns4.SubscribePolledRefreshReplyItemList_Def.schema
            TClist = [ns4.ItemValue_Def(pname=(ns,"Items"), aname="_Items", minOccurs=0, maxOccurs="unbounded", nillable=False, encoded=kw.get("encoded"))]
            self.attribute_typecode_dict = {}
            ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw)
            # attribute handling code
            self.attribute_typecode_dict["SubscriptionHandle"] = ZSI.TC.String()
            class Holder:
                __metaclass__ = pyclass_type
                typecode = self
                def __init__(self):
                    # pyclass
                    self._Items = []
                    return
            Holder.__name__ = "SubscribePolledRefreshReplyItemList_Holder"
            self.pyclass = Holder

    class ServerStatus_Def(ZSI.TCcompound.ComplexType, TypeDefinition):
        schema = "http://opcfoundation.org/webservices/XMLDA/1.0/"
        type = (schema, "ServerStatus")
        def __init__(self, pname, **kw):
            ns = ns4.ServerStatus_Def.schema
            TClist = [ZSI.TC.String(pname=(ns,"StatusInfo"), aname="_StatusInfo", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"VendorInfo"), aname="_VendorInfo", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"SupportedLocaleIDs"), aname="_SupportedLocaleIDs", minOccurs=0, maxOccurs="unbounded", nillable=False, encoded=kw.get("encoded")), ns4.interfaceVersion_Def(pname=(ns,"SupportedInterfaceVersions"), aname="_SupportedInterfaceVersions", minOccurs=0, maxOccurs="unbounded", nillable=False, encoded=kw.get("encoded"))]
            self.attribute_typecode_dict = {}
            ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw)
            # attribute handling code
            self.attribute_typecode_dict["StartTime"] = ZSI.TCtimes.gDateTime()
            self.attribute_typecode_dict["ProductVersion"] = ZSI.TC.String()
            class Holder:
                __metaclass__ = pyclass_type
                typecode = self
                def __init__(self):
                    # pyclass
                    self._StatusInfo = None
                    self._VendorInfo = None
                    self._SupportedLocaleIDs = []
                    self._SupportedInterfaceVersions = []
                    return
            Holder.__name__ = "ServerStatus_Holder"
            self.pyclass = Holder

    class interfaceVersion_Def(ZSI.TC.String, TypeDefinition):
        schema = "http://opcfoundation.org/webservices/XMLDA/1.0/"
        type = (schema, "interfaceVersion")
        def __init__(self, pname, **kw):
            ZSI.TC.String.__init__(self, pname, pyclass=None, **kw)
            class Holder(str):
                typecode = self
            self.pyclass = Holder

    class browseFilter_Def(ZSI.TC.String, TypeDefinition):
        schema = "http://opcfoundation.org/webservices/XMLDA/1.0/"
        type = (schema, "browseFilter")
        def __init__(self, pname, **kw):
            ZSI.TC.String.__init__(self, pname, pyclass=None, **kw)
            class Holder(str):
                typecode = self
            self.pyclass = Holder

    class BrowseElement_Def(ZSI.TCcompound.ComplexType, TypeDefinition):
        schema = "http://opcfoundation.org/webservices/XMLDA/1.0/"
        type = (schema, "BrowseElement")
        def __init__(self, pname, **kw):
            ns = ns4.BrowseElement_Def.schema
            TClist = [ns4.ItemProperty_Def(pname=(ns,"Properties"), aname="_Properties", minOccurs=0, maxOccurs="unbounded", nillable=False, encoded=kw.get("encoded"))]
            self.attribute_typecode_dict = {}
            ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw)
            # attribute handling code
            self.attribute_typecode_dict["Name"] = ZSI.TC.String()
            self.attribute_typecode_dict["ItemPath"] = ZSI.TC.String()
            self.attribute_typecode_dict["ItemName"] = ZSI.TC.String()
            self.attribute_typecode_dict["IsItem"] = ZSI.TC.Boolean()
            self.attribute_typecode_dict["HasChildren"] = ZSI.TC.Boolean()
            class Holder:
                __metaclass__ = pyclass_type
                typecode = self
                def __init__(self):
                    # pyclass
                    self._Properties = []
                    return
            Holder.__name__ = "BrowseElement_Holder"
            self.pyclass = Holder

    class ReadRequestItemList_Def(ZSI.TCcompound.ComplexType, TypeDefinition):
        schema = "http://opcfoundation.org/webservices/XMLDA/1.0/"
        type = (schema, "ReadRequestItemList")
        def __init__(self, pname, **kw):
            ns = ns4.ReadRequestItemList_Def.schema
            TClist = [ns4.ReadRequestItem_Def(pname=(ns,"Items"), aname="_Items", minOccurs=0, maxOccurs="unbounded", nillable=False, encoded=kw.get("encoded"))]
            self.attribute_typecode_dict = {}
            ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw)
            # attribute handling code
            self.attribute_typecode_dict["ItemPath"] = ZSI.TC.String()
            self.attribute_typecode_dict["ReqType"] = ZSI.TC.QName()
            self.attribute_typecode_dict["MaxAge"] = ZSI.TCnumbers.Iint()
            class Holder:
                __metaclass__ = pyclass_type
                typecode = self
                def __init__(self):
                    # pyclass
                    self._Items = []
                    return
            Holder.__name__ = "ReadRequestItemList_Holder"
            self.pyclass = Holder

    class ReadRequestItem_Def(ZSI.TCcompound.ComplexType, TypeDefinition):
        schema = "http://opcfoundation.org/webservices/XMLDA/1.0/"
        type = (schema, "ReadRequestItem")
        def __init__(self, pname, **kw):
            ns = ns4.ReadRequestItem_Def.schema
            TClist = []
            self.attribute_typecode_dict = {}
            ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw)
            # attribute handling code
            self.attribute_typecode_dict["ItemPath"] = ZSI.TC.String()
            self.attribute_typecode_dict["ReqType"] = ZSI.TC.QName()
            self.attribute_typecode_dict["ItemName"] = ZSI.TC.String()
            self.attribute_typecode_dict["ClientItemHandle"] = ZSI.TC.String()
            self.attribute_typecode_dict["MaxAge"] = ZSI.TCnumbers.Iint()
            class Holder:
                __metaclass__ = pyclass_type
                typecode = self
                def __init__(self):
                    # pyclass
                    return
            Holder.__name__ = "ReadRequestItem_Holder"
            self.pyclass = Holder

    class ReplyItemList_Def(ZSI.TCcompound.ComplexType, TypeDefinition):
        schema = "http://opcfoundation.org/webservices/XMLDA/1.0/"
        type = (schema, "ReplyItemList")
        def __init__(self, pname, **kw):
            ns = ns4.ReplyItemList_Def.schema
            TClist = [ns4.ItemValue_Def(pname=(ns,"Items"), aname="_Items", minOccurs=0, maxOccurs="unbounded", nillable=False, encoded=kw.get("encoded"))]
            self.attribute_typecode_dict = {}
            ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw)
            # attribute handling code
            self.attribute_typecode_dict["Reserved"] = ZSI.TC.String()
            class Holder:
                __metaclass__ = pyclass_type
                typecode = self
                def __init__(self):
                    # pyclass
                    self._Items = []
                    return
            Holder.__name__ = "ReplyItemList_Holder"
            self.pyclass = Holder

    class WriteRequestItemList_Def(ZSI.TCcompound.ComplexType, TypeDefinition):
        schema = "http://opcfoundation.org/webservices/XMLDA/1.0/"
        type = (schema, "WriteRequestItemList")
        def __init__(self, pname, **kw):
            ns = ns4.WriteRequestItemList_Def.schema
            TClist = [ns4.ItemValue_Def(pname=(ns,"Items"), aname="_Items", minOccurs=0, maxOccurs="unbounded", nillable=False, encoded=kw.get("encoded"))]
            self.attribute_typecode_dict = {}
            ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw)
            # attribute handling code
            self.attribute_typecode_dict["ItemPath"] = ZSI.TC.String()
            class Holder:
                __metaclass__ = pyclass_type
                typecode = self
                def __init__(self):
                    # pyclass
                    self._Items = []
                    return
            Holder.__name__ = "WriteRequestItemList_Holder"
            self.pyclass = Holder

    class GetProperties_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration):
        schema = "http://opcfoundation.org/webservices/XMLDA/1.0/"
        literal = "GetProperties"
        def __init__(self, **kw):
            ns = ns4.GetProperties_Dec.schema
            TClist = [ns4.ItemIdentifier_Def(pname=(ns,"ItemIDs"), aname="_ItemIDs", minOccurs=0, maxOccurs="unbounded", nillable=False, encoded=kw.get("encoded")), ZSI.TC.QName(pname=(ns,"PropertyNames"), aname="_PropertyNames", minOccurs=0, maxOccurs="unbounded", nillable=False, encoded=kw.get("encoded"))]
            kw["pname"] = ("http://opcfoundation.org/webservices/XMLDA/1.0/","GetProperties")
            kw["aname"] = "_GetProperties"
            self.attribute_typecode_dict = {}
            ZSI.TCcompound.ComplexType.__init__(self, None, TClist, inorder=0, **kw)
            # attribute handling code
            self.attribute_typecode_dict["LocaleID"] = ZSI.TC.String()
            self.attribute_typecode_dict["ClientRequestHandle"] = ZSI.TC.String()
            self.attribute_typecode_dict["ItemPath"] = ZSI.TC.String()
            self.attribute_typecode_dict["ReturnAllProperties"] = ZSI.TC.Boolean()
            self.attribute_typecode_dict["ReturnPropertyValues"] = ZSI.TC.Boolean()
            self.attribute_typecode_dict["ReturnErrorText"] = ZSI.TC.Boolean()
            class Holder:
                __metaclass__ = pyclass_type
                typecode = self
                def __init__(self):
                    # pyclass
                    self._ItemIDs = []
                    self._PropertyNames = []
                    return
            Holder.__name__ = "GetProperties_Holder"
            self.pyclass = Holder

    class GetPropertiesResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration):
        schema = "http://opcfoundation.org/webservices/XMLDA/1.0/"
        literal = "GetPropertiesResponse"
        def __init__(self, **kw):
            ns = ns4.GetPropertiesResponse_Dec.schema
            TClist = [ns4.ReplyBase_Def(pname=(ns,"GetPropertiesResult"), aname="_GetPropertiesResult", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ns4.PropertyReplyList_Def(pname=(ns,"PropertyLists"), aname="_PropertyLists", minOccurs=0, maxOccurs="unbounded", nillable=False, encoded=kw.get("encoded")), ns4.OPCError_Def(pname=(ns,"Errors"), aname="_Errors", minOccurs=0, maxOccurs="unbounded", nillable=False, encoded=kw.get("encoded"))]
            kw["pname"] = ("http://opcfoundation.org/webservices/XMLDA/1.0/","GetPropertiesResponse")
            kw["aname"] = "_GetPropertiesResponse"
            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._GetPropertiesResult = None
                    self._PropertyLists = []
                    self._Errors = []
                    return
            Holder.__name__ = "GetPropertiesResponse_Holder"
            self.pyclass = Holder

    class Subscribe_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration):
        schema = "http://opcfoundation.org/webservices/XMLDA/1.0/"
        literal = "Subscribe"
        def __init__(self, **kw):
            ns = ns4.Subscribe_Dec.schema
            TClist = [ns4.RequestOptions_Def(pname=(ns,"Options"), aname="_Options", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ns4.SubscribeRequestItemList_Def(pname=(ns,"ItemList"), aname="_ItemList", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded"))]
            kw["pname"] = ("http://opcfoundation.org/webservices/XMLDA/1.0/","Subscribe")
            kw["aname"] = "_Subscribe"
            self.attribute_typecode_dict = {}
            ZSI.TCcompound.ComplexType.__init__(self, None, TClist, inorder=0, **kw)
            # attribute handling code
            self.attribute_typecode_dict["ReturnValuesOnReply"] = ZSI.TC.Boolean()
            self.attribute_typecode_dict["SubscriptionPingRate"] = ZSI.TCnumbers.Iint()
            class Holder:
                __metaclass__ = pyclass_type
                typecode = self
                def __init__(self):
                    # pyclass
                    self._Options = None
                    self._ItemList = None
                    return
            Holder.__name__ = "Subscribe_Holder"
            self.pyclass = Holder

    class SubscribeResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration):
        schema = "http://opcfoundation.org/webservices/XMLDA/1.0/"
        literal = "SubscribeResponse"
        def __init__(self, **kw):
            ns = ns4.SubscribeResponse_Dec.schema
            TClist = [ns4.ReplyBase_Def(pname=(ns,"SubscribeResult"), aname="_SubscribeResult", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ns4.SubscribeReplyItemList_Def(pname=(ns,"RItemList"), aname="_RItemList", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ns4.OPCError_Def(pname=(ns,"Errors"), aname="_Errors", minOccurs=0, maxOccurs="unbounded", nillable=False, encoded=kw.get("encoded"))]
            kw["pname"] = ("http://opcfoundation.org/webservices/XMLDA/1.0/","SubscribeResponse")
            kw["aname"] = "_SubscribeResponse"
            self.attribute_typecode_dict = {}
            ZSI.TCcompound.ComplexType.__init__(self, None, TClist, inorder=0, **kw)
            # attribute handling code
            self.attribute_typecode_dict["ServerSubHandle"] = ZSI.TC.String()
            class Holder:
                __metaclass__ = pyclass_type
                typecode = self
                def __init__(self):
                    # pyclass
                    self._SubscribeResult = None
                    self._RItemList = None
                    self._Errors = []
                    return
            Holder.__name__ = "SubscribeResponse_Holder"
            self.pyclass = Holder

    class SubscriptionPolledRefresh_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration):
        schema = "http://opcfoundation.org/webservices/XMLDA/1.0/"
        literal = "SubscriptionPolledRefresh"
        def __init__(self, **kw):
            ns = ns4.SubscriptionPolledRefresh_Dec.schema
            TClist = [ns4.RequestOptions_Def(pname=(ns,"Options"), aname="_Options", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"ServerSubHandles"), aname="_ServerSubHandles", minOccurs=0, maxOccurs="unbounded", nillable=False, encoded=kw.get("encoded"))]
            kw["pname"] = ("http://opcfoundation.org/webservices/XMLDA/1.0/","SubscriptionPolledRefresh")
            kw["aname"] = "_SubscriptionPolledRefresh"
            self.attribute_typecode_dict = {}
            ZSI.TCcompound.ComplexType.__init__(self, None, TClist, inorder=0, **kw)
            # attribute handling code
            self.attribute_typecode_dict["HoldTime"] = ZSI.TCtimes.gDateTime()
            self.attribute_typecode_dict["WaitTime"] = ZSI.TCnumbers.Iint()
            self.attribute_typecode_dict["ReturnAllItems"] = ZSI.TC.Boolean()
            class Holder:
                __metaclass__ = pyclass_type
                typecode = self
                def __init__(self):
                    # pyclass
                    self._Options = None
                    self._ServerSubHandles = []
                    return
            Holder.__name__ = "SubscriptionPolledRefresh_Holder"
            self.pyclass = Holder

    class SubscriptionPolledRefreshResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration):
        schema = "http://opcfoundation.org/webservices/XMLDA/1.0/"
        literal = "SubscriptionPolledRefreshResponse"
        def __init__(self, **kw):
            ns = ns4.SubscriptionPolledRefreshResponse_Dec.schema
            TClist = [ns4.ReplyBase_Def(pname=(ns,"SubscriptionPolledRefreshResult"), aname="_SubscriptionPolledRefreshResult", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"InvalidServerSubHandles"), aname="_InvalidServerSubHandles", minOccurs=0, maxOccurs="unbounded", nillable=False, encoded=kw.get("encoded")), ns4.SubscribePolledRefreshReplyItemList_Def(pname=(ns,"RItemList"), aname="_RItemList", minOccurs=0, maxOccurs="unbounded", nillable=False, encoded=kw.get("encoded")), ns4.OPCError_Def(pname=(ns,"Errors"), aname="_Errors", minOccurs=0, maxOccurs="unbounded", nillable=False, encoded=kw.get("encoded"))]
            kw["pname"] = ("http://opcfoundation.org/webservices/XMLDA/1.0/","SubscriptionPolledRefreshResponse")
            kw["aname"] = "_SubscriptionPolledRefreshResponse"
            self.attribute_typecode_dict = {}
            ZSI.TCcompound.ComplexType.__init__(self, None, TClist, inorder=0, **kw)
            # attribute handling code
            self.attribute_typecode_dict["DataBufferOverflow"] = ZSI.TC.Boolean()
            class Holder:
                __metaclass__ = pyclass_type
                typecode = self
                def __init__(self):
                    # pyclass
                    self._SubscriptionPolledRefreshResult = None
                    self._InvalidServerSubHandles = []
                    self._RItemList = []
                    self._Errors = []
                    return
            Holder.__name__ = "SubscriptionPolledRefreshResponse_Holder"
            self.pyclass = Holder

    class SubscriptionCancel_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration):
        schema = "http://opcfoundation.org/webservices/XMLDA/1.0/"
        literal = "SubscriptionCancel"
        def __init__(self, **kw):
            ns = ns4.SubscriptionCancel_Dec.schema
            TClist = []
            kw["pname"] = ("http://opcfoundation.org/webservices/XMLDA/1.0/","SubscriptionCancel")
            kw["aname"] = "_SubscriptionCancel"
            self.attribute_typecode_dict = {}
            ZSI.TCcompound.ComplexType.__init__(self, None, TClist, inorder=0, **kw)
            # attribute handling code
            self.attribute_typecode_dict["ServerSubHandle"] = ZSI.TC.String()
            self.attribute_typecode_dict["ClientRequestHandle"] = ZSI.TC.String()
            class Holder:
                __metaclass__ = pyclass_type
                typecode = self
                def __init__(self):
                    # pyclass
                    return
            Holder.__name__ = "SubscriptionCancel_Holder"
            self.pyclass = Holder

    class SubscriptionCancelResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration):
        schema = "http://opcfoundation.org/webservices/XMLDA/1.0/"
        literal = "SubscriptionCancelResponse"
        def __init__(self, **kw):
            ns = ns4.SubscriptionCancelResponse_Dec.schema
            TClist = []
            kw["pname"] = ("http://opcfoundation.org/webservices/XMLDA/1.0/","SubscriptionCancelResponse")
            kw["aname"] = "_SubscriptionCancelResponse"
            self.attribute_typecode_dict = {}
            ZSI.TCcompound.ComplexType.__init__(self, None, TClist, inorder=0, **kw)
            # attribute handling code
            self.attribute_typecode_dict["ClientRequestHandle"] = ZSI.TC.String()
            class Holder:
                __metaclass__ = pyclass_type
                typecode = self
                def __init__(self):
                    # pyclass
                    return
            Holder.__name__ = "SubscriptionCancelResponse_Holder"
            self.pyclass = Holder

    class GetStatus_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration):
        schema = "http://opcfoundation.org/webservices/XMLDA/1.0/"
        literal = "GetStatus"
        def __init__(self, **kw):
            ns = ns4.GetStatus_Dec.schema
            TClist = []
            kw["pname"] = ("http://opcfoundation.org/webservices/XMLDA/1.0/","GetStatus")
            kw["aname"] = "_GetStatus"
            self.attribute_typecode_dict = {}
            ZSI.TCcompound.ComplexType.__init__(self, None, TClist, inorder=0, **kw)
            # attribute handling code
            self.attribute_typecode_dict["LocaleID"] = ZSI.TC.String()
            self.attribute_typecode_dict["ClientRequestHandle"] = ZSI.TC.String()
            class Holder:
                __metaclass__ = pyclass_type
                typecode = self
                def __init__(self):
                    # pyclass
                    return
            Holder.__name__ = "GetStatus_Holder"
            self.pyclass = Holder

    class GetStatusResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration):
        schema = "http://opcfoundation.org/webservices/XMLDA/1.0/"
        literal = "GetStatusResponse"
        def __init__(self, **kw):
            ns = ns4.GetStatusResponse_Dec.schema
            TClist = [ns4.ReplyBase_Def(pname=(ns,"GetStatusResult"), aname="_GetStatusResult", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ns4.ServerStatus_Def(pname=(ns,"Status"), aname="_Status", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded"))]
            kw["pname"] = ("http://opcfoundation.org/webservices/XMLDA/1.0/","GetStatusResponse")
            kw["aname"] = "_GetStatusResponse"
            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._GetStatusResult = None
                    self._Status = None
                    return
            Holder.__name__ = "GetStatusResponse_Holder"
            self.pyclass = Holder

    class Browse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration):
        schema = "http://opcfoundation.org/webservices/XMLDA/1.0/"
        literal = "Browse"
        def __init__(self, **kw):
            ns = ns4.Browse_Dec.schema
            TClist = [ZSI.TC.QName(pname=(ns,"PropertyNames"), aname="_PropertyNames", minOccurs=0, maxOccurs="unbounded", nillable=False, encoded=kw.get("encoded"))]
            kw["pname"] = ("http://opcfoundation.org/webservices/XMLDA/1.0/","Browse")
            kw["aname"] = "_Browse"
            self.attribute_typecode_dict = {}
            ZSI.TCcompound.ComplexType.__init__(self, None, TClist, inorder=0, **kw)
            # attribute handling code
            self.attribute_typecode_dict["LocaleID"] = ZSI.TC.String()
            self.attribute_typecode_dict["ClientRequestHandle"] = ZSI.TC.String()
            self.attribute_typecode_dict["ItemPath"] = ZSI.TC.String()
            self.attribute_typecode_dict["ItemName"] = ZSI.TC.String()
            self.attribute_typecode_dict["ContinuationPoint"] = ZSI.TC.String()
            self.attribute_typecode_dict["MaxElementsReturned"] = ZSI.TCnumbers.Iint()
            self.attribute_typecode_dict["BrowseFilter"] = ns4.browseFilter_Def(None)
            self.attribute_typecode_dict["ElementNameFilter"] = ZSI.TC.String()
            self.attribute_typecode_dict["VendorFilter"] = ZSI.TC.String()
            self.attribute_typecode_dict["ReturnAllProperties"] = ZSI.TC.Boolean()
            self.attribute_typecode_dict["ReturnPropertyValues"] = ZSI.TC.Boolean()
            self.attribute_typecode_dict["ReturnErrorText"] = ZSI.TC.Boolean()
            class Holder:
                __metaclass__ = pyclass_type
                typecode = self
                def __init__(self):
                    # pyclass
                    self._PropertyNames = []
                    return
            Holder.__name__ = "Browse_Holder"
            self.pyclass = Holder

    class BrowseResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration):
        schema = "http://opcfoundation.org/webservices/XMLDA/1.0/"
        literal = "BrowseResponse"
        def __init__(self, **kw):
            ns = ns4.BrowseResponse_Dec.schema
            TClist = [ns4.ReplyBase_Def(pname=(ns,"BrowseResult"), aname="_BrowseResult", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ns4.BrowseElement_Def(pname=(ns,"Elements"), aname="_Elements", minOccurs=0, maxOccurs="unbounded", nillable=False, encoded=kw.get("encoded")), ns4.OPCError_Def(pname=(ns,"Errors"), aname="_Errors", minOccurs=0, maxOccurs="unbounded", nillable=False, encoded=kw.get("encoded"))]
            kw["pname"] = ("http://opcfoundation.org/webservices/XMLDA/1.0/","BrowseResponse")
            kw["aname"] = "_BrowseResponse"
            self.attribute_typecode_dict = {}
            ZSI.TCcompound.ComplexType.__init__(self, None, TClist, inorder=0, **kw)
            # attribute handling code
            self.attribute_typecode_dict["ContinuationPoint"] = ZSI.TC.String()
            self.attribute_typecode_dict["MoreElements"] = ZSI.TC.Boolean()
            class Holder:
                __metaclass__ = pyclass_type
                typecode = self
                def __init__(self):
                    # pyclass
                    self._BrowseResult = None
                    self._Elements = []
                    self._Errors = []
                    return
            Holder.__name__ = "BrowseResponse_Holder"
            self.pyclass = Holder

    class Read_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration):
        schema = "http://opcfoundation.org/webservices/XMLDA/1.0/"
        literal = "Read"
        def __init__(self, **kw):
            ns = ns4.Read_Dec.schema
            TClist = [ns4.RequestOptions_Def(pname=(ns,"Options"), aname="_Options", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ns4.ReadRequestItemList_Def(pname=(ns,"ItemList"), aname="_ItemList", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded"))]
            kw["pname"] = ("http://opcfoundation.org/webservices/XMLDA/1.0/","Read")
            kw["aname"] = "_Read"
            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._Options = None
                    self._ItemList = None
                    return
            Holder.__name__ = "Read_Holder"
            self.pyclass = Holder

    class ReadResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration):
        schema = "http://opcfoundation.org/webservices/XMLDA/1.0/"
        literal = "ReadResponse"
        def __init__(self, **kw):
            ns = ns4.ReadResponse_Dec.schema
            TClist = [ns4.ReplyBase_Def(pname=(ns,"ReadResult"), aname="_ReadResult", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ns4.ReplyItemList_Def(pname=(ns,"RItemList"), aname="_RItemList", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ns4.OPCError_Def(pname=(ns,"Errors"), aname="_Errors", minOccurs=0, maxOccurs="unbounded", nillable=False, encoded=kw.get("encoded"))]
            kw["pname"] = ("http://opcfoundation.org/webservices/XMLDA/1.0/","ReadResponse")
            kw["aname"] = "_ReadResponse"
            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._ReadResult = None
                    self._RItemList = None
                    self._Errors = []
                    return
            Holder.__name__ = "ReadResponse_Holder"
            self.pyclass = Holder

    class Write_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration):
        schema = "http://opcfoundation.org/webservices/XMLDA/1.0/"
        literal = "Write"
        def __init__(self, **kw):
            ns = ns4.Write_Dec.schema
            TClist = [ns4.RequestOptions_Def(pname=(ns,"Options"), aname="_Options", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ns4.WriteRequestItemList_Def(pname=(ns,"ItemList"), aname="_ItemList", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded"))]
            kw["pname"] = ("http://opcfoundation.org/webservices/XMLDA/1.0/","Write")
            kw["aname"] = "_Write"
            self.attribute_typecode_dict = {}
            ZSI.TCcompound.ComplexType.__init__(self, None, TClist, inorder=0, **kw)
            # attribute handling code
            self.attribute_typecode_dict["ReturnValuesOnReply"] = ZSI.TC.Boolean()
            class Holder:
                __metaclass__ = pyclass_type
                typecode = self
                def __init__(self):
                    # pyclass
                    self._Options = None
                    self._ItemList = None
                    return
            Holder.__name__ = "Write_Holder"
            self.pyclass = Holder

    class WriteResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration):
        schema = "http://opcfoundation.org/webservices/XMLDA/1.0/"
        literal = "WriteResponse"
        def __init__(self, **kw):
            ns = ns4.WriteResponse_Dec.schema
            TClist = [ns4.ReplyBase_Def(pname=(ns,"WriteResult"), aname="_WriteResult", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ns4.ReplyItemList_Def(pname=(ns,"RItemList"), aname="_RItemList", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ns4.OPCError_Def(pname=(ns,"Errors"), aname="_Errors", minOccurs=0, maxOccurs="unbounded", nillable=False, encoded=kw.get("encoded"))]
            kw["pname"] = ("http://opcfoundation.org/webservices/XMLDA/1.0/","WriteResponse")
            kw["aname"] = "_WriteResponse"
            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._WriteResult = None
                    self._RItemList = None
                    self._Errors = []
                    return
            Holder.__name__ = "WriteResponse_Holder"
            self.pyclass = Holder

# end class ns4 (tns: http://opcfoundation.org/webservices/XMLDA/1.0/)
