home *** CD-ROM | disk | FTP | other *** search
/ Maximum CD 2011 October / maximum-cd-2011-10.iso / DiscContents / digsby_setup.exe / lib / msn / SOAP / xml / wst.pyo (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2011-06-22  |  26.4 KB  |  692 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.6)
  3.  
  4. import ZSI
  5. import ZSI.TCcompound as ZSI
  6. import ZSI.wstools.Namespaces as NS
  7. from ZSI.schema import LocalElementDeclaration, ElementDeclaration, TypeDefinition, GTD, GED
  8. from ZSI.generate.pyclass import pyclass_type
  9.  
  10. class wst:
  11.     targetNamespace = NS.WSTRUST.BASE
  12.     
  13.     class RequestSecurityTokenType_Def(ZSI.TCcompound.ComplexType, TypeDefinition):
  14.         schema = NS.WSTRUST.BASE
  15.         type = (schema, 'RequestSecurityTokenType')
  16.         
  17.         def __init__(self, pname, ofwhat = (), attributes = None, extend = False, restrict = False, **kw):
  18.             ns = wst.RequestSecurityTokenType_Def.schema
  19.             TClist = [
  20.                 GED(NS.WSTRUST.BASE, 'TokenType', lazy = False, isref = True)(minOccurs = 0, maxOccurs = 1, nillable = False, encoded = kw.get('encoded')),
  21.                 GED(NS.WSTRUST.BASE, 'RequestType', lazy = False, isref = True)(minOccurs = 1, maxOccurs = 1, nillable = False, encoded = kw.get('encoded')),
  22.                 GED(NS.WSP.POLICY, 'AppliesTo', lazy = False, isref = True)(minOccurs = 0, maxOccurs = 1, nillable = False, encoded = kw.get('encoded')),
  23.                 GED(NS.WSP.POLICY, 'PolicyReference', lazy = False, isref = True)(minOccurs = 0, maxOccurs = 1, nillable = False, encoded = kw.get('encoded')),
  24.                 ZSI.TC.AnyElement(aname = '_any', minOccurs = 0, maxOccurs = 'unbounded', nillable = False, processContents = 'lax')]
  25.             if not attributes:
  26.                 pass
  27.             self.attribute_typecode_dict = { }
  28.             if extend:
  29.                 TClist += ofwhat
  30.             
  31.             if restrict:
  32.                 TClist = ofwhat
  33.             else:
  34.                 self.attribute_typecode_dict['Id'] = ZSI.TC.String()
  35.             ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname = pname, inorder = 0, **kw)
  36.             
  37.             class Holder(()):
  38.                 __metaclass__ = pyclass_type
  39.                 typecode = self
  40.                 
  41.                 def __init__(self):
  42.                     self._TokenType = None
  43.                     self._RequestType = None
  44.                     self._AppliesTo = None
  45.                     self._PolicyReference = None
  46.                     self._any = []
  47.  
  48.  
  49.             Holder.__name__ = 'RequestSecurityTokenType_Holder'
  50.             self.pyclass = Holder
  51.  
  52.  
  53.     
  54.     class RequestTypeOpenEnum_Def(ZSI.TC.URI, TypeDefinition):
  55.         schema = NS.WSTRUST.BASE
  56.         type = (schema, 'RequestTypeOpenEnum')
  57.         
  58.         def __init__(self, pname, **kw):
  59.             ZSI.TC.URI.__init__(self, pname, pyclass = None, **kw)
  60.             
  61.             class Holder((str,)):
  62.                 typecode = self
  63.  
  64.             self.pyclass = Holder
  65.  
  66.  
  67.     
  68.     class RequestTypeEnum_Def(ZSI.TC.URI, TypeDefinition):
  69.         schema = NS.WSTRUST.BASE
  70.         type = (schema, 'RequestTypeEnum')
  71.         
  72.         def __init__(self, pname, **kw):
  73.             ZSI.TC.URI.__init__(self, pname, pyclass = None, **kw)
  74.             
  75.             class Holder((str,)):
  76.                 typecode = self
  77.  
  78.             self.pyclass = Holder
  79.  
  80.  
  81.     
  82.     class RequestSecurityTokenResponseType_Def(ZSI.TCcompound.ComplexType, TypeDefinition):
  83.         schema = NS.WSTRUST.BASE
  84.         type = (schema, 'RequestSecurityTokenResponseType')
  85.         
  86.         def __init__(self, pname, ofwhat = (), attributes = None, extend = False, restrict = False, **kw):
  87.             ns = wst.RequestSecurityTokenResponseType_Def.schema
  88.             TClist = [
  89.                 GED(NS.WSTRUST.BASE, 'TokenType', lazy = False, isref = True)(minOccurs = 0, maxOccurs = 1, nillable = False, encoded = kw.get('encoded')),
  90.                 GED(NS.WSP.POLICY, 'AppliesTo', lazy = False, isref = True)(minOccurs = 0, maxOccurs = 1, nillable = False, encoded = kw.get('encoded')),
  91.                 GED(NS.WSTRUST.BASE, 'Lifetime', lazy = False, isref = True)(minOccurs = 0, maxOccurs = 1, nillable = False, encoded = kw.get('encoded')),
  92.                 GED(NS.WSTRUST.BASE, 'RequestedSecurityToken', lazy = False, isref = True)(minOccurs = 0, maxOccurs = 1, nillable = False, encoded = kw.get('encoded')),
  93.                 GED(NS.WSTRUST.BASE, 'RequestedAttachedReference', lazy = False, isref = True)(minOccurs = 0, maxOccurs = 1, nillable = False, encoded = kw.get('encoded')),
  94.                 GED(NS.WSTRUST.BASE, 'RequestedUnattachedReference', lazy = False, isref = True)(minOccurs = 0, maxOccurs = 1, nillable = False, encoded = kw.get('encoded')),
  95.                 GED(NS.WSTRUST.BASE, 'RequestedTokenReference', lazy = False, isref = True)(minOccurs = 0, maxOccurs = 1, nillable = False, encoded = kw.get('encoded')),
  96.                 GED(NS.WSTRUST.BASE, 'RequestedProofToken', lazy = False, isref = True)(minOccurs = 0, maxOccurs = 1, nillable = False, encoded = kw.get('encoded'))]
  97.             if not attributes:
  98.                 pass
  99.             self.attribute_typecode_dict = { }
  100.             if extend:
  101.                 TClist += ofwhat
  102.             
  103.             if restrict:
  104.                 TClist = ofwhat
  105.             
  106.             ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname = pname, inorder = 0, **kw)
  107.             
  108.             class Holder(()):
  109.                 __metaclass__ = pyclass_type
  110.                 typecode = self
  111.                 
  112.                 def __init__(self):
  113.                     self._TokenType = None
  114.                     self._AppliesTo = None
  115.                     self._Lifetime = None
  116.                     self._RequestedSecurityToken = None
  117.                     self._RequestedAttachedReference = None
  118.                     self._RequestedUnattachedReference = None
  119.                     self._RequestedTokenReference = None
  120.                     self._RequestedProofToken = None
  121.  
  122.  
  123.             Holder.__name__ = 'RequestSecurityTokenResponseType_Holder'
  124.             self.pyclass = Holder
  125.  
  126.  
  127.     
  128.     class RequestedTokenReferenceType_Def(ZSI.TCcompound.ComplexType, TypeDefinition):
  129.         schema = NS.WSTRUST.BASE
  130.         type = (schema, 'RequestedTokenReferenceType')
  131.         
  132.         def __init__(self, pname, ofwhat = (), attributes = None, extend = False, restrict = False, **kw):
  133.             ns = wst.RequestedTokenReferenceType_Def.schema
  134.             TClist = [
  135.                 GED(NS.OASIS.WSSE, 'KeyIdentifier', lazy = False, isref = True)(minOccurs = 1, maxOccurs = 1, nillable = False, encoded = kw.get('encoded')),
  136.                 GED(NS.OASIS.WSSE, 'Reference', lazy = False, isref = True)(minOccurs = 1, maxOccurs = 1, nillable = False, encoded = kw.get('encoded'))]
  137.             if not attributes:
  138.                 pass
  139.             self.attribute_typecode_dict = { }
  140.             if extend:
  141.                 TClist += ofwhat
  142.             
  143.             if restrict:
  144.                 TClist = ofwhat
  145.             
  146.             ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname = pname, inorder = 0, **kw)
  147.             
  148.             class Holder(()):
  149.                 __metaclass__ = pyclass_type
  150.                 typecode = self
  151.                 
  152.                 def __init__(self):
  153.                     self._KeyIdentifier = None
  154.                     self._Reference = None
  155.  
  156.  
  157.             Holder.__name__ = 'RequestedTokenReferenceType_Holder'
  158.             self.pyclass = Holder
  159.  
  160.  
  161.     
  162.     class RequestedProofTokenType_Def(ZSI.TCcompound.ComplexType, TypeDefinition):
  163.         schema = NS.WSTRUST.BASE
  164.         type = (schema, 'RequestedProofTokenType')
  165.         
  166.         def __init__(self, pname, ofwhat = (), attributes = None, extend = False, restrict = False, **kw):
  167.             ns = wst.RequestedProofTokenType_Def.schema
  168.             TClist = [
  169.                 GED(NS.WSTRUST.BASE, 'BinarySecret', lazy = False, isref = True)(minOccurs = 1, maxOccurs = 1, nillable = False, encoded = kw.get('encoded'))]
  170.             if not attributes:
  171.                 pass
  172.             self.attribute_typecode_dict = { }
  173.             if extend:
  174.                 TClist += ofwhat
  175.             
  176.             if restrict:
  177.                 TClist = ofwhat
  178.             
  179.             ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname = pname, inorder = 0, **kw)
  180.             
  181.             class Holder(()):
  182.                 __metaclass__ = pyclass_type
  183.                 typecode = self
  184.                 
  185.                 def __init__(self):
  186.                     self._BinarySecret = None
  187.  
  188.  
  189.             Holder.__name__ = 'RequestedProofTokenType_Holder'
  190.             self.pyclass = Holder
  191.  
  192.  
  193.     
  194.     class BinarySecretType_Def(ZSI.TC.String, TypeDefinition):
  195.         schema = NS.WSTRUST.BASE
  196.         type = (schema, 'BinarySecretType')
  197.         
  198.         def __init__(self, pname, **kw):
  199.             if getattr(self, 'attribute_typecode_dict', None) is None:
  200.                 self.attribute_typecode_dict = { }
  201.             
  202.             ZSI.TC.String.__init__(self, pname, **kw)
  203.             
  204.             class Holder((str,)):
  205.                 __metaclass__ = pyclass_type
  206.                 typecode = self
  207.  
  208.             self.pyclass = Holder
  209.  
  210.  
  211.     
  212.     class BinarySecretTypeEnum_Def(ZSI.TC.URI, TypeDefinition):
  213.         schema = NS.WSTRUST.BASE
  214.         type = (schema, 'BinarySecretTypeEnum')
  215.         
  216.         def __init__(self, pname, **kw):
  217.             ZSI.TC.URI.__init__(self, pname, pyclass = None, **kw)
  218.             
  219.             class Holder((str,)):
  220.                 typecode = self
  221.  
  222.             self.pyclass = Holder
  223.  
  224.  
  225.     
  226.     class BinarySecretTypeOpenEnum_Def(ZSI.TC.Union, TypeDefinition):
  227.         memberTypes = [
  228.             (NS.WSTRUST.BASE, u'BinarySecretTypeEnum'),
  229.             (NS.SCHEMA.BASE, u'anyURI')]
  230.         schema = NS.WSTRUST.BASE
  231.         type = (schema, 'BinarySecretTypeOpenEnum')
  232.         
  233.         def __init__(self, pname, **kw):
  234.             ZSI.TC.Union.__init__(self, pname, **kw)
  235.  
  236.  
  237.     
  238.     class RequestedSecurityTokenType_Def(ZSI.TCcompound.ComplexType, TypeDefinition):
  239.         schema = NS.WSTRUST.BASE
  240.         type = (schema, 'RequestedSecurityTokenType')
  241.         
  242.         def __init__(self, pname, ofwhat = (), attributes = None, extend = False, restrict = False, **kw):
  243.             ns = wst.RequestedSecurityTokenType_Def.schema
  244.             TClist = [
  245.                 ZSI.TC.AnyElement(aname = '_any', minOccurs = 1, maxOccurs = 1, nillable = False, processContents = 'lax'),
  246.                 GTD(NS.WSTRUST.BASE, 'EncryptedDataType', lazy = False)(pname = (ns, 'EncryptedData'), aname = '_EncryptedData', minOccurs = 0, maxOccurs = 1, nillable = False, typed = False, encoded = kw.get('encoded')),
  247.                 GED(NS.OASIS.WSSE, 'BinarySecurityToken', lazy = False, isref = True)(minOccurs = 0, maxOccurs = 1, nillable = False, encoded = kw.get('encoded'))]
  248.             if not attributes:
  249.                 pass
  250.             self.attribute_typecode_dict = { }
  251.             if extend:
  252.                 TClist += ofwhat
  253.             
  254.             if restrict:
  255.                 TClist = ofwhat
  256.             
  257.             ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname = pname, inorder = 0, **kw)
  258.             
  259.             class Holder(()):
  260.                 __metaclass__ = pyclass_type
  261.                 typecode = self
  262.                 
  263.                 def __init__(self):
  264.                     self._any = None
  265.                     self._EncryptedData = None
  266.                     self._BinarySecurityToken = None
  267.                     self._Assertion = None
  268.  
  269.  
  270.             Holder.__name__ = 'RequestedSecurityTokenType_Holder'
  271.             self.pyclass = Holder
  272.  
  273.  
  274.     
  275.     class LifetimeType_Def(ZSI.TCcompound.ComplexType, TypeDefinition):
  276.         schema = NS.WSTRUST.BASE
  277.         type = (schema, 'LifetimeType')
  278.         
  279.         def __init__(self, pname, ofwhat = (), attributes = None, extend = False, restrict = False, **kw):
  280.             ns = wst.LifetimeType_Def.schema
  281.             TClist = [
  282.                 GED(NS.OASIS.UTILITY, 'Created', lazy = False, isref = True)(minOccurs = 0, maxOccurs = 1, nillable = False, encoded = kw.get('encoded')),
  283.                 GED(NS.OASIS.UTILITY, 'Expires', lazy = False, isref = True)(minOccurs = 0, maxOccurs = 1, nillable = False, encoded = kw.get('encoded'))]
  284.             if not attributes:
  285.                 pass
  286.             self.attribute_typecode_dict = { }
  287.             if extend:
  288.                 TClist += ofwhat
  289.             
  290.             if restrict:
  291.                 TClist = ofwhat
  292.             
  293.             ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname = pname, inorder = 0, **kw)
  294.             
  295.             class Holder(()):
  296.                 __metaclass__ = pyclass_type
  297.                 typecode = self
  298.                 
  299.                 def __init__(self):
  300.                     self._Created = None
  301.                     self._Expires = None
  302.  
  303.  
  304.             Holder.__name__ = 'LifetimeType_Holder'
  305.             self.pyclass = Holder
  306.  
  307.  
  308.     
  309.     class RequestSecurityTokenResponseCollectionType_Def(ZSI.TCcompound.ComplexType, TypeDefinition):
  310.         schema = NS.WSTRUST.BASE
  311.         type = (schema, 'RequestSecurityTokenResponseCollectionType')
  312.         
  313.         def __init__(self, pname, ofwhat = (), attributes = None, extend = False, restrict = False, **kw):
  314.             ns = wst.RequestSecurityTokenResponseCollectionType_Def.schema
  315.             TClist = [
  316.                 GED(NS.WSTRUST.BASE, 'RequestSecurityTokenResponse', lazy = False, isref = True)(minOccurs = 1, maxOccurs = 'unbounded', nillable = False, encoded = kw.get('encoded'))]
  317.             if not attributes:
  318.                 pass
  319.             self.attribute_typecode_dict = { }
  320.             if extend:
  321.                 TClist += ofwhat
  322.             
  323.             if restrict:
  324.                 TClist = ofwhat
  325.             
  326.             ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname = pname, inorder = 0, **kw)
  327.             
  328.             class Holder(()):
  329.                 __metaclass__ = pyclass_type
  330.                 typecode = self
  331.                 
  332.                 def __init__(self):
  333.                     self._RequestSecurityTokenResponse = None
  334.  
  335.  
  336.             Holder.__name__ = 'RequestSecurityTokenResponseCollectionType_Holder'
  337.             self.pyclass = Holder
  338.  
  339.  
  340.     
  341.     class CipherDataType_Def(ZSI.TCcompound.ComplexType, TypeDefinition):
  342.         schema = NS.WSTRUST.BASE
  343.         type = (schema, 'CipherDataType')
  344.         
  345.         def __init__(self, pname, ofwhat = (), attributes = None, extend = False, restrict = False, **kw):
  346.             ns = wst.CipherDataType_Def.schema
  347.             TClist = [
  348.                 ZSI.TC.String(pname = (ns, 'CipherValue'), aname = '_CipherValue', minOccurs = 1, maxOccurs = 1, nillable = False, typed = False, encoded = kw.get('encoded'))]
  349.             if not attributes:
  350.                 pass
  351.             self.attribute_typecode_dict = { }
  352.             if extend:
  353.                 TClist += ofwhat
  354.             
  355.             if restrict:
  356.                 TClist = ofwhat
  357.             
  358.             ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname = pname, inorder = 0, **kw)
  359.             
  360.             class Holder(()):
  361.                 __metaclass__ = pyclass_type
  362.                 typecode = self
  363.                 
  364.                 def __init__(self):
  365.                     self._CipherValue = None
  366.  
  367.  
  368.             Holder.__name__ = 'CipherDataType_Holder'
  369.             self.pyclass = Holder
  370.  
  371.  
  372.     
  373.     class EncryptedDataType_Def(ZSI.TCcompound.ComplexType, TypeDefinition):
  374.         schema = NS.WSTRUST.BASE
  375.         type = (schema, 'EncryptedDataType')
  376.         
  377.         def __init__(self, pname, ofwhat = (), attributes = None, extend = False, restrict = False, **kw):
  378.             ns = wst.EncryptedDataType_Def.schema
  379.             TClist = [
  380.                 GTD(NS.WSTRUST.BASE, 'EncryptionMethodType', lazy = False)(pname = (ns, 'EncryptionMethod'), aname = '_EncryptionMethod', minOccurs = 1, maxOccurs = 1, nillable = False, typed = False, encoded = kw.get('encoded')),
  381.                 GED(NS.DSIG.BASE, 'KeyInfo', lazy = False, isref = True)(minOccurs = 1, maxOccurs = 1, nillable = False, encoded = kw.get('encoded')),
  382.                 GTD(NS.WSTRUST.BASE, 'CipherDataType', lazy = False)(pname = (ns, 'CipherData'), aname = '_CipherData', minOccurs = 1, maxOccurs = 1, nillable = False, typed = False, encoded = kw.get('encoded'))]
  383.             if not attributes:
  384.                 pass
  385.             self.attribute_typecode_dict = { }
  386.             if extend:
  387.                 TClist += ofwhat
  388.             
  389.             if restrict:
  390.                 TClist = ofwhat
  391.             else:
  392.                 self.attribute_typecode_dict['Id'] = ZSI.TC.String()
  393.                 self.attribute_typecode_dict['Type'] = ZSI.TC.String()
  394.             ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname = pname, inorder = 0, **kw)
  395.             
  396.             class Holder(()):
  397.                 __metaclass__ = pyclass_type
  398.                 typecode = self
  399.                 
  400.                 def __init__(self):
  401.                     self._EncryptionMethod = None
  402.                     self._KeyInfo = None
  403.                     self._CipherData = None
  404.  
  405.  
  406.             Holder.__name__ = 'EncryptedDataType_Holder'
  407.             self.pyclass = Holder
  408.  
  409.  
  410.     
  411.     class EncryptionMethodType_Def(ZSI.TCcompound.ComplexType, TypeDefinition):
  412.         schema = NS.WSTRUST.BASE
  413.         type = (schema, 'EncryptionMethodType')
  414.         
  415.         def __init__(self, pname, ofwhat = (), attributes = None, extend = False, restrict = False, **kw):
  416.             ns = wst.EncryptionMethodType_Def.schema
  417.             TClist = []
  418.             if not attributes:
  419.                 pass
  420.             self.attribute_typecode_dict = { }
  421.             if extend:
  422.                 TClist += ofwhat
  423.             
  424.             if restrict:
  425.                 TClist = ofwhat
  426.             else:
  427.                 self.attribute_typecode_dict['Algorithm'] = ZSI.TC.String()
  428.             ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname = pname, inorder = 0, **kw)
  429.             
  430.             class Holder(()):
  431.                 __metaclass__ = pyclass_type
  432.                 typecode = self
  433.                 
  434.                 def __init__(self):
  435.                     pass
  436.  
  437.  
  438.             Holder.__name__ = 'EncryptionMethodType_Holder'
  439.             self.pyclass = Holder
  440.  
  441.  
  442.     
  443.     class RequestSecurityToken_Dec(ElementDeclaration):
  444.         literal = 'RequestSecurityToken'
  445.         schema = NS.WSTRUST.BASE
  446.         substitutionGroup = None
  447.         
  448.         def __init__(self, **kw):
  449.             kw['pname'] = (NS.WSTRUST.BASE, 'RequestSecurityToken')
  450.             kw['aname'] = '_RequestSecurityToken'
  451.             if wst.RequestSecurityTokenType_Def not in wst.RequestSecurityToken_Dec.__bases__:
  452.                 bases = list(wst.RequestSecurityToken_Dec.__bases__)
  453.                 bases.insert(0, wst.RequestSecurityTokenType_Def)
  454.                 wst.RequestSecurityToken_Dec.__bases__ = tuple(bases)
  455.             
  456.             wst.RequestSecurityTokenType_Def.__init__(self, **kw)
  457.             if self.pyclass is not None:
  458.                 self.pyclass.__name__ = 'RequestSecurityToken_Dec_Holder'
  459.             
  460.  
  461.  
  462.     
  463.     class TokenType_Dec(ZSI.TC.URI, ElementDeclaration):
  464.         literal = 'TokenType'
  465.         schema = NS.WSTRUST.BASE
  466.         
  467.         def __init__(self, **kw):
  468.             kw['pname'] = (NS.WSTRUST.BASE, 'TokenType')
  469.             kw['aname'] = '_TokenType'
  470.             
  471.             class IHolder((str,)):
  472.                 typecode = self
  473.  
  474.             kw['pyclass'] = IHolder
  475.             IHolder.__name__ = '_TokenType_immutable_holder'
  476.             ZSI.TC.URI.__init__(self, **kw)
  477.  
  478.  
  479.     
  480.     class RequestType_Dec(ElementDeclaration):
  481.         literal = 'RequestType'
  482.         schema = NS.WSTRUST.BASE
  483.         substitutionGroup = None
  484.         
  485.         def __init__(self, **kw):
  486.             kw['pname'] = (NS.WSTRUST.BASE, 'RequestType')
  487.             kw['aname'] = '_RequestType'
  488.             if wst.RequestTypeOpenEnum_Def not in wst.RequestType_Dec.__bases__:
  489.                 bases = list(wst.RequestType_Dec.__bases__)
  490.                 bases.insert(0, wst.RequestTypeOpenEnum_Def)
  491.                 wst.RequestType_Dec.__bases__ = tuple(bases)
  492.             
  493.             wst.RequestTypeOpenEnum_Def.__init__(self, **kw)
  494.             if self.pyclass is not None:
  495.                 self.pyclass.__name__ = 'RequestType_Dec_Holder'
  496.             
  497.  
  498.  
  499.     
  500.     class RequestSecurityTokenResponse_Dec(ElementDeclaration):
  501.         literal = 'RequestSecurityTokenResponse'
  502.         schema = NS.WSTRUST.BASE
  503.         substitutionGroup = None
  504.         
  505.         def __init__(self, **kw):
  506.             kw['pname'] = (NS.WSTRUST.BASE, 'RequestSecurityTokenResponse')
  507.             kw['aname'] = '_RequestSecurityTokenResponse'
  508.             if wst.RequestSecurityTokenResponseType_Def not in wst.RequestSecurityTokenResponse_Dec.__bases__:
  509.                 bases = list(wst.RequestSecurityTokenResponse_Dec.__bases__)
  510.                 bases.insert(0, wst.RequestSecurityTokenResponseType_Def)
  511.                 wst.RequestSecurityTokenResponse_Dec.__bases__ = tuple(bases)
  512.             
  513.             wst.RequestSecurityTokenResponseType_Def.__init__(self, **kw)
  514.             if self.pyclass is not None:
  515.                 self.pyclass.__name__ = 'RequestSecurityTokenResponse_Dec_Holder'
  516.             
  517.  
  518.  
  519.     
  520.     class RequestedAttachedReference_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration):
  521.         literal = 'RequestedAttachedReference'
  522.         schema = NS.WSTRUST.BASE
  523.         
  524.         def __init__(self, **kw):
  525.             ns = wst.RequestedAttachedReference_Dec.schema
  526.             TClist = [
  527.                 GED(NS.OASIS.WSSE, 'SecurityTokenReference', lazy = False, isref = True)(minOccurs = 1, maxOccurs = 1, nillable = False, encoded = kw.get('encoded'))]
  528.             kw['pname'] = (NS.WSTRUST.BASE, 'RequestedAttachedReference')
  529.             kw['aname'] = '_RequestedAttachedReference'
  530.             self.attribute_typecode_dict = { }
  531.             ZSI.TCcompound.ComplexType.__init__(self, None, TClist, inorder = 0, **kw)
  532.             
  533.             class Holder(()):
  534.                 __metaclass__ = pyclass_type
  535.                 typecode = self
  536.                 
  537.                 def __init__(self):
  538.                     self._SecurityTokenReference = None
  539.  
  540.  
  541.             Holder.__name__ = 'RequestedAttachedReference_Holder'
  542.             self.pyclass = Holder
  543.  
  544.  
  545.     
  546.     class RequestedUnattachedReference_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration):
  547.         literal = 'RequestedUnattachedReference'
  548.         schema = NS.WSTRUST.BASE
  549.         
  550.         def __init__(self, **kw):
  551.             ns = wst.RequestedUnattachedReference_Dec.schema
  552.             TClist = [
  553.                 GED(NS.OASIS.WSSE, 'SecurityTokenReference', lazy = False, isref = True)(minOccurs = 1, maxOccurs = 1, nillable = False, encoded = kw.get('encoded'))]
  554.             kw['pname'] = (NS.WSTRUST.BASE, 'RequestedUnattachedReference')
  555.             kw['aname'] = '_RequestedUnattachedReference'
  556.             self.attribute_typecode_dict = { }
  557.             ZSI.TCcompound.ComplexType.__init__(self, None, TClist, inorder = 0, **kw)
  558.             
  559.             class Holder(()):
  560.                 __metaclass__ = pyclass_type
  561.                 typecode = self
  562.                 
  563.                 def __init__(self):
  564.                     self._SecurityTokenReference = None
  565.  
  566.  
  567.             Holder.__name__ = 'RequestedUnattachedReference_Holder'
  568.             self.pyclass = Holder
  569.  
  570.  
  571.     
  572.     class RequestedTokenReference_Dec(ElementDeclaration):
  573.         literal = 'RequestedTokenReference'
  574.         schema = NS.WSTRUST.BASE
  575.         substitutionGroup = None
  576.         
  577.         def __init__(self, **kw):
  578.             kw['pname'] = (NS.WSTRUST.BASE, 'RequestedTokenReference')
  579.             kw['aname'] = '_RequestedTokenReference'
  580.             if wst.RequestedTokenReferenceType_Def not in wst.RequestedTokenReference_Dec.__bases__:
  581.                 bases = list(wst.RequestedTokenReference_Dec.__bases__)
  582.                 bases.insert(0, wst.RequestedTokenReferenceType_Def)
  583.                 wst.RequestedTokenReference_Dec.__bases__ = tuple(bases)
  584.             
  585.             wst.RequestedTokenReferenceType_Def.__init__(self, **kw)
  586.             if self.pyclass is not None:
  587.                 self.pyclass.__name__ = 'RequestedTokenReference_Dec_Holder'
  588.             
  589.  
  590.  
  591.     
  592.     class RequestedProofToken_Dec(ElementDeclaration):
  593.         literal = 'RequestedProofToken'
  594.         schema = NS.WSTRUST.BASE
  595.         substitutionGroup = None
  596.         
  597.         def __init__(self, **kw):
  598.             kw['pname'] = (NS.WSTRUST.BASE, 'RequestedProofToken')
  599.             kw['aname'] = '_RequestedProofToken'
  600.             if wst.RequestedProofTokenType_Def not in wst.RequestedProofToken_Dec.__bases__:
  601.                 bases = list(wst.RequestedProofToken_Dec.__bases__)
  602.                 bases.insert(0, wst.RequestedProofTokenType_Def)
  603.                 wst.RequestedProofToken_Dec.__bases__ = tuple(bases)
  604.             
  605.             wst.RequestedProofTokenType_Def.__init__(self, **kw)
  606.             if self.pyclass is not None:
  607.                 self.pyclass.__name__ = 'RequestedProofToken_Dec_Holder'
  608.             
  609.  
  610.  
  611.     
  612.     class BinarySecret_Dec(ElementDeclaration):
  613.         literal = 'BinarySecret'
  614.         schema = NS.WSTRUST.BASE
  615.         substitutionGroup = None
  616.         
  617.         def __init__(self, **kw):
  618.             kw['pname'] = (NS.WSTRUST.BASE, 'BinarySecret')
  619.             kw['aname'] = '_BinarySecret'
  620.             if wst.BinarySecretType_Def not in wst.BinarySecret_Dec.__bases__:
  621.                 bases = list(wst.BinarySecret_Dec.__bases__)
  622.                 bases.insert(0, wst.BinarySecretType_Def)
  623.                 wst.BinarySecret_Dec.__bases__ = tuple(bases)
  624.             
  625.             wst.BinarySecretType_Def.__init__(self, **kw)
  626.             if self.pyclass is not None:
  627.                 self.pyclass.__name__ = 'BinarySecret_Dec_Holder'
  628.             
  629.  
  630.  
  631.     
  632.     class RequestedSecurityToken_Dec(ElementDeclaration):
  633.         literal = 'RequestedSecurityToken'
  634.         schema = NS.WSTRUST.BASE
  635.         substitutionGroup = None
  636.         
  637.         def __init__(self, **kw):
  638.             kw['pname'] = (NS.WSTRUST.BASE, 'RequestedSecurityToken')
  639.             kw['aname'] = '_RequestedSecurityToken'
  640.             if wst.RequestedSecurityTokenType_Def not in wst.RequestedSecurityToken_Dec.__bases__:
  641.                 bases = list(wst.RequestedSecurityToken_Dec.__bases__)
  642.                 bases.insert(0, wst.RequestedSecurityTokenType_Def)
  643.                 wst.RequestedSecurityToken_Dec.__bases__ = tuple(bases)
  644.             
  645.             wst.RequestedSecurityTokenType_Def.__init__(self, **kw)
  646.             if self.pyclass is not None:
  647.                 self.pyclass.__name__ = 'RequestedSecurityToken_Dec_Holder'
  648.             
  649.  
  650.  
  651.     
  652.     class Lifetime_Dec(ElementDeclaration):
  653.         literal = 'Lifetime'
  654.         schema = NS.WSTRUST.BASE
  655.         substitutionGroup = None
  656.         
  657.         def __init__(self, **kw):
  658.             kw['pname'] = (NS.WSTRUST.BASE, 'Lifetime')
  659.             kw['aname'] = '_Lifetime'
  660.             if wst.LifetimeType_Def not in wst.Lifetime_Dec.__bases__:
  661.                 bases = list(wst.Lifetime_Dec.__bases__)
  662.                 bases.insert(0, wst.LifetimeType_Def)
  663.                 wst.Lifetime_Dec.__bases__ = tuple(bases)
  664.             
  665.             wst.LifetimeType_Def.__init__(self, **kw)
  666.             if self.pyclass is not None:
  667.                 self.pyclass.__name__ = 'Lifetime_Dec_Holder'
  668.             
  669.  
  670.  
  671.     
  672.     class RequestSecurityTokenResponseCollection_Dec(ElementDeclaration):
  673.         literal = 'RequestSecurityTokenResponseCollection'
  674.         schema = NS.WSTRUST.BASE
  675.         substitutionGroup = None
  676.         
  677.         def __init__(self, **kw):
  678.             kw['pname'] = (NS.WSTRUST.BASE, 'RequestSecurityTokenResponseCollection')
  679.             kw['aname'] = '_RequestSecurityTokenResponseCollection'
  680.             if wst.RequestSecurityTokenResponseCollectionType_Def not in wst.RequestSecurityTokenResponseCollection_Dec.__bases__:
  681.                 bases = list(wst.RequestSecurityTokenResponseCollection_Dec.__bases__)
  682.                 bases.insert(0, wst.RequestSecurityTokenResponseCollectionType_Def)
  683.                 wst.RequestSecurityTokenResponseCollection_Dec.__bases__ = tuple(bases)
  684.             
  685.             wst.RequestSecurityTokenResponseCollectionType_Def.__init__(self, **kw)
  686.             if self.pyclass is not None:
  687.                 self.pyclass.__name__ = 'RequestSecurityTokenResponseCollection_Dec_Holder'
  688.             
  689.  
  690.  
  691.  
  692.