#!/usr/bin/env python

#
# Generated Mon May  2 14:23:33 2011 by parse_xsd.py version 0.4.
#

import saml2
from saml2 import SamlBase

import xmldsig as ds

NAMESPACE = 'http://www.w3.org/2001/04/xmlenc#'

class KeySizeType_(SamlBase):
    """The http://www.w3.org/2001/04/xmlenc#:KeySizeType element """

    c_tag = 'KeySizeType'
    c_namespace = NAMESPACE
    c_value_type = {'base': 'integer'}
    c_children = SamlBase.c_children.copy()
    c_attributes = SamlBase.c_attributes.copy()
    c_child_order = SamlBase.c_child_order[:]
    c_cardinality = SamlBase.c_cardinality.copy()

def key_size_type__from_string(xml_string):
    return saml2.create_class_from_xml_string(KeySizeType_, xml_string)


class CipherDataType_CipherValue(SamlBase):

    c_tag = 'CipherValue'
    c_namespace = NAMESPACE
    c_value_type = {'base': 'base64Binary'}
    c_children = SamlBase.c_children.copy()
    c_attributes = SamlBase.c_attributes.copy()
    c_child_order = SamlBase.c_child_order[:]
    c_cardinality = SamlBase.c_cardinality.copy()

def cipher_data_type__cipher_value_from_string(xml_string):
    return saml2.create_class_from_xml_string(CipherDataType_CipherValue, xml_string)


class TransformsType_(SamlBase):
    """The http://www.w3.org/2001/04/xmlenc#:TransformsType element """

    c_tag = 'TransformsType'
    c_namespace = NAMESPACE
    c_children = SamlBase.c_children.copy()
    c_attributes = SamlBase.c_attributes.copy()
    c_child_order = SamlBase.c_child_order[:]
    c_cardinality = SamlBase.c_cardinality.copy()
    c_children['{http://www.w3.org/2000/09/xmldsig#}Transform'] = ('transform', [ds.Transform])
    c_cardinality['transform'] = {"min":1}
    c_child_order.extend(['transform'])

    def __init__(self,
            transform=None,
            text=None,
            extension_elements=None,
            extension_attributes=None,
        ):
        SamlBase.__init__(self, 
                text=text,
                extension_elements=extension_elements,
                extension_attributes=extension_attributes,
                )
        self.transform=transform or []

def transforms_type__from_string(xml_string):
    return saml2.create_class_from_xml_string(TransformsType_, xml_string)


class AgreementMethodType_KA_Nonce(SamlBase):

    c_tag = 'KA_Nonce'
    c_namespace = NAMESPACE
    c_value_type = {'base': 'base64Binary'}
    c_children = SamlBase.c_children.copy()
    c_attributes = SamlBase.c_attributes.copy()
    c_child_order = SamlBase.c_child_order[:]
    c_cardinality = SamlBase.c_cardinality.copy()

def agreement_method_type__k_a__nonce_from_string(xml_string):
    return saml2.create_class_from_xml_string(AgreementMethodType_KA_Nonce, xml_string)


class AgreementMethodType_OriginatorKeyInfo(ds.KeyInfoType_):

    c_tag = 'OriginatorKeyInfo'
    c_namespace = NAMESPACE
    c_children = ds.KeyInfoType_.c_children.copy()
    c_attributes = ds.KeyInfoType_.c_attributes.copy()
    c_child_order = ds.KeyInfoType_.c_child_order[:]
    c_cardinality = ds.KeyInfoType_.c_cardinality.copy()

def agreement_method_type__originator_key_info_from_string(xml_string):
    return saml2.create_class_from_xml_string(AgreementMethodType_OriginatorKeyInfo, xml_string)


class AgreementMethodType_RecipientKeyInfo(ds.KeyInfoType_):

    c_tag = 'RecipientKeyInfo'
    c_namespace = NAMESPACE
    c_children = ds.KeyInfoType_.c_children.copy()
    c_attributes = ds.KeyInfoType_.c_attributes.copy()
    c_child_order = ds.KeyInfoType_.c_child_order[:]
    c_cardinality = ds.KeyInfoType_.c_cardinality.copy()

def agreement_method_type__recipient_key_info_from_string(xml_string):
    return saml2.create_class_from_xml_string(AgreementMethodType_RecipientKeyInfo, xml_string)


class AgreementMethodType_(SamlBase):
    """The http://www.w3.org/2001/04/xmlenc#:AgreementMethodType element """

    c_tag = 'AgreementMethodType'
    c_namespace = NAMESPACE
    c_children = SamlBase.c_children.copy()
    c_attributes = SamlBase.c_attributes.copy()
    c_child_order = SamlBase.c_child_order[:]
    c_cardinality = SamlBase.c_cardinality.copy()
    c_children['{http://www.w3.org/2001/04/xmlenc#}KA_Nonce'] = ('k_a__nonce', AgreementMethodType_KA_Nonce)
    c_cardinality['k_a__nonce'] = {"min":0, "max":1}
    c_children['{http://www.w3.org/2001/04/xmlenc#}OriginatorKeyInfo'] = ('originator_key_info', AgreementMethodType_OriginatorKeyInfo)
    c_cardinality['originator_key_info'] = {"min":0, "max":1}
    c_children['{http://www.w3.org/2001/04/xmlenc#}RecipientKeyInfo'] = ('recipient_key_info', AgreementMethodType_RecipientKeyInfo)
    c_cardinality['recipient_key_info'] = {"min":0, "max":1}
    c_attributes['Algorithm'] = ('algorithm', 'anyURI', True)
    c_child_order.extend(['k_a__nonce', 'originator_key_info', 'recipient_key_info'])

    def __init__(self,
            k_a__nonce=None,
            originator_key_info=None,
            recipient_key_info=None,
            algorithm=None,
            text=None,
            extension_elements=None,
            extension_attributes=None,
        ):
        SamlBase.__init__(self, 
                text=text,
                extension_elements=extension_elements,
                extension_attributes=extension_attributes,
                )
        self.k_a__nonce=k_a__nonce
        self.originator_key_info=originator_key_info
        self.recipient_key_info=recipient_key_info
        self.algorithm=algorithm

def agreement_method_type__from_string(xml_string):
    return saml2.create_class_from_xml_string(AgreementMethodType_, xml_string)


class ReferenceType_(SamlBase):
    """The http://www.w3.org/2001/04/xmlenc#:ReferenceType element """

    c_tag = 'ReferenceType'
    c_namespace = NAMESPACE
    c_children = SamlBase.c_children.copy()
    c_attributes = SamlBase.c_attributes.copy()
    c_child_order = SamlBase.c_child_order[:]
    c_cardinality = SamlBase.c_cardinality.copy()
    c_attributes['URI'] = ('uri', 'anyURI', True)

    def __init__(self,
            uri=None,
            text=None,
            extension_elements=None,
            extension_attributes=None,
        ):
        SamlBase.__init__(self, 
                text=text,
                extension_elements=extension_elements,
                extension_attributes=extension_attributes,
                )
        self.uri=uri

def reference_type__from_string(xml_string):
    return saml2.create_class_from_xml_string(ReferenceType_, xml_string)


class EncryptionPropertyType_(SamlBase):
    """The http://www.w3.org/2001/04/xmlenc#:EncryptionPropertyType element """

    c_tag = 'EncryptionPropertyType'
    c_namespace = NAMESPACE
    c_children = SamlBase.c_children.copy()
    c_attributes = SamlBase.c_attributes.copy()
    c_child_order = SamlBase.c_child_order[:]
    c_cardinality = SamlBase.c_cardinality.copy()
    c_attributes['Target'] = ('target', 'anyURI', False)
    c_attributes['Id'] = ('id', 'ID', False)

    def __init__(self,
            target=None,
            id=None,
            text=None,
            extension_elements=None,
            extension_attributes=None,
        ):
        SamlBase.__init__(self, 
                text=text,
                extension_elements=extension_elements,
                extension_attributes=extension_attributes,
                )
        self.target=target
        self.id=id

def encryption_property_type__from_string(xml_string):
    return saml2.create_class_from_xml_string(EncryptionPropertyType_, xml_string)


class EncryptionMethodType_KeySize(KeySizeType_):

    c_tag = 'KeySize'
    c_namespace = NAMESPACE
    c_children = KeySizeType_.c_children.copy()
    c_attributes = KeySizeType_.c_attributes.copy()
    c_child_order = KeySizeType_.c_child_order[:]
    c_cardinality = KeySizeType_.c_cardinality.copy()

def encryption_method_type__key_size_from_string(xml_string):
    return saml2.create_class_from_xml_string(EncryptionMethodType_KeySize, xml_string)


class EncryptionMethodType_OAEPparams(SamlBase):

    c_tag = 'OAEPparams'
    c_namespace = NAMESPACE
    c_value_type = {'base': 'base64Binary'}
    c_children = SamlBase.c_children.copy()
    c_attributes = SamlBase.c_attributes.copy()
    c_child_order = SamlBase.c_child_order[:]
    c_cardinality = SamlBase.c_cardinality.copy()

def encryption_method_type__oae_pparams_from_string(xml_string):
    return saml2.create_class_from_xml_string(EncryptionMethodType_OAEPparams, xml_string)


class EncryptionMethodType_(SamlBase):
    """The http://www.w3.org/2001/04/xmlenc#:EncryptionMethodType element """

    c_tag = 'EncryptionMethodType'
    c_namespace = NAMESPACE
    c_children = SamlBase.c_children.copy()
    c_attributes = SamlBase.c_attributes.copy()
    c_child_order = SamlBase.c_child_order[:]
    c_cardinality = SamlBase.c_cardinality.copy()
    c_children['{http://www.w3.org/2001/04/xmlenc#}KeySize'] = ('key_size', EncryptionMethodType_KeySize)
    c_cardinality['key_size'] = {"min":0, "max":1}
    c_children['{http://www.w3.org/2001/04/xmlenc#}OAEPparams'] = ('oae_pparams', EncryptionMethodType_OAEPparams)
    c_cardinality['oae_pparams'] = {"min":0, "max":1}
    c_attributes['Algorithm'] = ('algorithm', 'anyURI', True)
    c_child_order.extend(['key_size', 'oae_pparams'])

    def __init__(self,
            key_size=None,
            oae_pparams=None,
            algorithm=None,
            text=None,
            extension_elements=None,
            extension_attributes=None,
        ):
        SamlBase.__init__(self, 
                text=text,
                extension_elements=extension_elements,
                extension_attributes=extension_attributes,
                )
        self.key_size=key_size
        self.oae_pparams=oae_pparams
        self.algorithm=algorithm

def encryption_method_type__from_string(xml_string):
    return saml2.create_class_from_xml_string(EncryptionMethodType_, xml_string)


class CipherReferenceType_Transforms(TransformsType_):

    c_tag = 'Transforms'
    c_namespace = NAMESPACE
    c_children = TransformsType_.c_children.copy()
    c_attributes = TransformsType_.c_attributes.copy()
    c_child_order = TransformsType_.c_child_order[:]
    c_cardinality = TransformsType_.c_cardinality.copy()

def cipher_reference_type__transforms_from_string(xml_string):
    return saml2.create_class_from_xml_string(CipherReferenceType_Transforms, xml_string)


class CipherReferenceType_(SamlBase):
    """The http://www.w3.org/2001/04/xmlenc#:CipherReferenceType element """

    c_tag = 'CipherReferenceType'
    c_namespace = NAMESPACE
    c_children = SamlBase.c_children.copy()
    c_attributes = SamlBase.c_attributes.copy()
    c_child_order = SamlBase.c_child_order[:]
    c_cardinality = SamlBase.c_cardinality.copy()
    c_children['{http://www.w3.org/2001/04/xmlenc#}Transforms'] = ('transforms', CipherReferenceType_Transforms)
    c_cardinality['transforms'] = {"min":0, "max":1}
    c_attributes['URI'] = ('uri', 'anyURI', True)
    c_child_order.extend(['transforms'])

    def __init__(self,
            transforms=None,
            uri=None,
            text=None,
            extension_elements=None,
            extension_attributes=None,
        ):
        SamlBase.__init__(self, 
                text=text,
                extension_elements=extension_elements,
                extension_attributes=extension_attributes,
                )
        self.transforms=transforms
        self.uri=uri

def cipher_reference_type__from_string(xml_string):
    return saml2.create_class_from_xml_string(CipherReferenceType_, xml_string)


class EncryptedType_EncryptionMethod(EncryptionMethodType_):

    c_tag = 'EncryptionMethod'
    c_namespace = NAMESPACE
    c_children = EncryptionMethodType_.c_children.copy()
    c_attributes = EncryptionMethodType_.c_attributes.copy()
    c_child_order = EncryptionMethodType_.c_child_order[:]
    c_cardinality = EncryptionMethodType_.c_cardinality.copy()

def encrypted_type__encryption_method_from_string(xml_string):
    return saml2.create_class_from_xml_string(EncryptedType_EncryptionMethod, xml_string)



class AgreementMethod(AgreementMethodType_):
    """The http://www.w3.org/2001/04/xmlenc#:AgreementMethod element """

    c_tag = 'AgreementMethod'
    c_namespace = NAMESPACE
    c_children = AgreementMethodType_.c_children.copy()
    c_attributes = AgreementMethodType_.c_attributes.copy()
    c_child_order = AgreementMethodType_.c_child_order[:]
    c_cardinality = AgreementMethodType_.c_cardinality.copy()

def agreement_method_from_string(xml_string):
    return saml2.create_class_from_xml_string(AgreementMethod, xml_string)


class ReferenceList_DataReference(ReferenceType_):

    c_tag = 'DataReference'
    c_namespace = NAMESPACE
    c_children = ReferenceType_.c_children.copy()
    c_attributes = ReferenceType_.c_attributes.copy()
    c_child_order = ReferenceType_.c_child_order[:]
    c_cardinality = ReferenceType_.c_cardinality.copy()

def reference_list__data_reference_from_string(xml_string):
    return saml2.create_class_from_xml_string(ReferenceList_DataReference, xml_string)


class ReferenceList_KeyReference(ReferenceType_):

    c_tag = 'KeyReference'
    c_namespace = NAMESPACE
    c_children = ReferenceType_.c_children.copy()
    c_attributes = ReferenceType_.c_attributes.copy()
    c_child_order = ReferenceType_.c_child_order[:]
    c_cardinality = ReferenceType_.c_cardinality.copy()

def reference_list__key_reference_from_string(xml_string):
    return saml2.create_class_from_xml_string(ReferenceList_KeyReference, xml_string)


class ReferenceList(SamlBase):
    """The http://www.w3.org/2001/04/xmlenc#:ReferenceList element """

    c_tag = 'ReferenceList'
    c_namespace = NAMESPACE
    c_children = SamlBase.c_children.copy()
    c_attributes = SamlBase.c_attributes.copy()
    c_child_order = SamlBase.c_child_order[:]
    c_cardinality = SamlBase.c_cardinality.copy()
    c_children['{http://www.w3.org/2001/04/xmlenc#}DataReference'] = ('data_reference', [ReferenceList_DataReference])
    c_cardinality['data_reference'] = {"min":0}
    c_children['{http://www.w3.org/2001/04/xmlenc#}KeyReference'] = ('key_reference', [ReferenceList_KeyReference])
    c_cardinality['key_reference'] = {"min":0}
    c_child_order.extend(['data_reference', 'key_reference'])

    def __init__(self,
            data_reference=None,
            key_reference=None,
            text=None,
            extension_elements=None,
            extension_attributes=None,
        ):
        SamlBase.__init__(self, 
                text=text,
                extension_elements=extension_elements,
                extension_attributes=extension_attributes,
                )
        self.data_reference=data_reference or []
        self.key_reference=key_reference or []

def reference_list_from_string(xml_string):
    return saml2.create_class_from_xml_string(ReferenceList, xml_string)


class EncryptionProperty(EncryptionPropertyType_):
    """The http://www.w3.org/2001/04/xmlenc#:EncryptionProperty element """

    c_tag = 'EncryptionProperty'
    c_namespace = NAMESPACE
    c_children = EncryptionPropertyType_.c_children.copy()
    c_attributes = EncryptionPropertyType_.c_attributes.copy()
    c_child_order = EncryptionPropertyType_.c_child_order[:]
    c_cardinality = EncryptionPropertyType_.c_cardinality.copy()

def encryption_property_from_string(xml_string):
    return saml2.create_class_from_xml_string(EncryptionProperty, xml_string)


class CipherReference(CipherReferenceType_):
    """The http://www.w3.org/2001/04/xmlenc#:CipherReference element """

    c_tag = 'CipherReference'
    c_namespace = NAMESPACE
    c_children = CipherReferenceType_.c_children.copy()
    c_attributes = CipherReferenceType_.c_attributes.copy()
    c_child_order = CipherReferenceType_.c_child_order[:]
    c_cardinality = CipherReferenceType_.c_cardinality.copy()

def cipher_reference_from_string(xml_string):
    return saml2.create_class_from_xml_string(CipherReference, xml_string)


class EncryptionPropertiesType_(SamlBase):
    """The http://www.w3.org/2001/04/xmlenc#:EncryptionPropertiesType element """

    c_tag = 'EncryptionPropertiesType'
    c_namespace = NAMESPACE
    c_children = SamlBase.c_children.copy()
    c_attributes = SamlBase.c_attributes.copy()
    c_child_order = SamlBase.c_child_order[:]
    c_cardinality = SamlBase.c_cardinality.copy()
    c_children['{http://www.w3.org/2001/04/xmlenc#}EncryptionProperty'] = ('encryption_property', [EncryptionProperty])
    c_cardinality['encryption_property'] = {"min":1}
    c_attributes['Id'] = ('id', 'ID', False)
    c_child_order.extend(['encryption_property'])

    def __init__(self,
            encryption_property=None,
            id=None,
            text=None,
            extension_elements=None,
            extension_attributes=None,
        ):
        SamlBase.__init__(self, 
                text=text,
                extension_elements=extension_elements,
                extension_attributes=extension_attributes,
                )
        self.encryption_property=encryption_property or []
        self.id=id

def encryption_properties_type__from_string(xml_string):
    return saml2.create_class_from_xml_string(EncryptionPropertiesType_, xml_string)


class CipherDataType_(SamlBase):
    """The http://www.w3.org/2001/04/xmlenc#:CipherDataType element """

    c_tag = 'CipherDataType'
    c_namespace = NAMESPACE
    c_children = SamlBase.c_children.copy()
    c_attributes = SamlBase.c_attributes.copy()
    c_child_order = SamlBase.c_child_order[:]
    c_cardinality = SamlBase.c_cardinality.copy()
    c_children['{http://www.w3.org/2001/04/xmlenc#}CipherValue'] = ('cipher_value', CipherDataType_CipherValue)
    c_cardinality['cipher_value'] = {"min":0, "max":1}
    c_children['{http://www.w3.org/2001/04/xmlenc#}CipherReference'] = ('cipher_reference', CipherReference)
    c_cardinality['cipher_reference'] = {"min":0, "max":1}
    c_child_order.extend(['cipher_value', 'cipher_reference'])

    def __init__(self,
            cipher_value=None,
            cipher_reference=None,
            text=None,
            extension_elements=None,
            extension_attributes=None,
        ):
        SamlBase.__init__(self, 
                text=text,
                extension_elements=extension_elements,
                extension_attributes=extension_attributes,
                )
        self.cipher_value=cipher_value
        self.cipher_reference=cipher_reference

def cipher_data_type__from_string(xml_string):
    return saml2.create_class_from_xml_string(CipherDataType_, xml_string)


class EncryptionProperties(EncryptionPropertiesType_):
    """The http://www.w3.org/2001/04/xmlenc#:EncryptionProperties element """

    c_tag = 'EncryptionProperties'
    c_namespace = NAMESPACE
    c_children = EncryptionPropertiesType_.c_children.copy()
    c_attributes = EncryptionPropertiesType_.c_attributes.copy()
    c_child_order = EncryptionPropertiesType_.c_child_order[:]
    c_cardinality = EncryptionPropertiesType_.c_cardinality.copy()

def encryption_properties_from_string(xml_string):
    return saml2.create_class_from_xml_string(EncryptionProperties, xml_string)


class CipherData(CipherDataType_):
    """The http://www.w3.org/2001/04/xmlenc#:CipherData element """

    c_tag = 'CipherData'
    c_namespace = NAMESPACE
    c_children = CipherDataType_.c_children.copy()
    c_attributes = CipherDataType_.c_attributes.copy()
    c_child_order = CipherDataType_.c_child_order[:]
    c_cardinality = CipherDataType_.c_cardinality.copy()

def cipher_data_from_string(xml_string):
    return saml2.create_class_from_xml_string(CipherData, xml_string)


class EncryptedType_(SamlBase):
    """The http://www.w3.org/2001/04/xmlenc#:EncryptedType element """

    c_tag = 'EncryptedType'
    c_namespace = NAMESPACE
    c_children = SamlBase.c_children.copy()
    c_attributes = SamlBase.c_attributes.copy()
    c_child_order = SamlBase.c_child_order[:]
    c_cardinality = SamlBase.c_cardinality.copy()
    c_children['{http://www.w3.org/2001/04/xmlenc#}EncryptionMethod'] = ('encryption_method', EncryptedType_EncryptionMethod)
    c_cardinality['encryption_method'] = {"min":0, "max":1}
    c_children['{http://www.w3.org/2000/09/xmldsig#}KeyInfo'] = ('key_info', ds.KeyInfo)
    c_cardinality['key_info'] = {"min":0, "max":1}
    c_children['{http://www.w3.org/2001/04/xmlenc#}CipherData'] = ('cipher_data', CipherData)
    c_children['{http://www.w3.org/2001/04/xmlenc#}EncryptionProperties'] = ('encryption_properties', EncryptionProperties)
    c_cardinality['encryption_properties'] = {"min":0, "max":1}
    c_attributes['Id'] = ('id', 'ID', False)
    c_attributes['Type'] = ('type', 'anyURI', False)
    c_attributes['MimeType'] = ('mime_type', 'string', False)
    c_attributes['Encoding'] = ('encoding', 'anyURI', False)
    c_child_order.extend(['encryption_method', 'key_info', 'cipher_data', 'encryption_properties'])

    def __init__(self,
            encryption_method=None,
            key_info=None,
            cipher_data=None,
            encryption_properties=None,
            id=None,
            type=None,
            mime_type=None,
            encoding=None,
            text=None,
            extension_elements=None,
            extension_attributes=None,
        ):
        SamlBase.__init__(self, 
                text=text,
                extension_elements=extension_elements,
                extension_attributes=extension_attributes,
                )
        self.encryption_method=encryption_method
        self.key_info=key_info
        self.cipher_data=cipher_data
        self.encryption_properties=encryption_properties
        self.id=id
        self.type=type
        self.mime_type=mime_type
        self.encoding=encoding


class EncryptedDataType_(EncryptedType_):
    """The http://www.w3.org/2001/04/xmlenc#:EncryptedDataType element """

    c_tag = 'EncryptedDataType'
    c_namespace = NAMESPACE
    c_children = EncryptedType_.c_children.copy()
    c_attributes = EncryptedType_.c_attributes.copy()
    c_child_order = EncryptedType_.c_child_order[:]
    c_cardinality = EncryptedType_.c_cardinality.copy()

def encrypted_data_type__from_string(xml_string):
    return saml2.create_class_from_xml_string(EncryptedDataType_, xml_string)


class EncryptedKeyType_CarriedKeyName(SamlBase):

    c_tag = 'CarriedKeyName'
    c_namespace = NAMESPACE
    c_value_type = {'base': 'string'}
    c_children = SamlBase.c_children.copy()
    c_attributes = SamlBase.c_attributes.copy()
    c_child_order = SamlBase.c_child_order[:]
    c_cardinality = SamlBase.c_cardinality.copy()

def encrypted_key_type__carried_key_name_from_string(xml_string):
    return saml2.create_class_from_xml_string(EncryptedKeyType_CarriedKeyName, xml_string)


class EncryptedKeyType_(EncryptedType_):
    """The http://www.w3.org/2001/04/xmlenc#:EncryptedKeyType element """

    c_tag = 'EncryptedKeyType'
    c_namespace = NAMESPACE
    c_children = EncryptedType_.c_children.copy()
    c_attributes = EncryptedType_.c_attributes.copy()
    c_child_order = EncryptedType_.c_child_order[:]
    c_cardinality = EncryptedType_.c_cardinality.copy()
    c_children['{http://www.w3.org/2001/04/xmlenc#}ReferenceList'] = ('reference_list', ReferenceList)
    c_cardinality['reference_list'] = {"min":0, "max":1}
    c_children['{http://www.w3.org/2001/04/xmlenc#}CarriedKeyName'] = ('carried_key_name', EncryptedKeyType_CarriedKeyName)
    c_cardinality['carried_key_name'] = {"min":0, "max":1}
    c_attributes['Recipient'] = ('recipient', 'string', False)
    c_child_order.extend(['reference_list', 'carried_key_name'])

    def __init__(self,
            reference_list=None,
            carried_key_name=None,
            recipient=None,
            encryption_method=None,
            key_info=None,
            cipher_data=None,
            encryption_properties=None,
            id=None,
            type=None,
            mime_type=None,
            encoding=None,
            text=None,
            extension_elements=None,
            extension_attributes=None,
        ):
        EncryptedType_.__init__(self, 
                encryption_method=encryption_method,
                key_info=key_info,
                cipher_data=cipher_data,
                encryption_properties=encryption_properties,
                id=id,
                type=type,
                mime_type=mime_type,
                encoding=encoding,
                text=text,
                extension_elements=extension_elements,
                extension_attributes=extension_attributes,
                )
        self.reference_list=reference_list
        self.carried_key_name=carried_key_name
        self.recipient=recipient

def encrypted_key_type__from_string(xml_string):
    return saml2.create_class_from_xml_string(EncryptedKeyType_, xml_string)


class EncryptedData(EncryptedDataType_):
    """The http://www.w3.org/2001/04/xmlenc#:EncryptedData element """

    c_tag = 'EncryptedData'
    c_namespace = NAMESPACE
    c_children = EncryptedDataType_.c_children.copy()
    c_attributes = EncryptedDataType_.c_attributes.copy()
    c_child_order = EncryptedDataType_.c_child_order[:]
    c_cardinality = EncryptedDataType_.c_cardinality.copy()

def encrypted_data_from_string(xml_string):
    return saml2.create_class_from_xml_string(EncryptedData, xml_string)


class EncryptedKey(EncryptedKeyType_):
    """The http://www.w3.org/2001/04/xmlenc#:EncryptedKey element """

    c_tag = 'EncryptedKey'
    c_namespace = NAMESPACE
    c_children = EncryptedKeyType_.c_children.copy()
    c_attributes = EncryptedKeyType_.c_attributes.copy()
    c_child_order = EncryptedKeyType_.c_child_order[:]
    c_cardinality = EncryptedKeyType_.c_cardinality.copy()

def encrypted_key_from_string(xml_string):
    return saml2.create_class_from_xml_string(EncryptedKey, xml_string)


ELEMENT_FROM_STRING = {
    EncryptionMethodType_.c_tag: encryption_method_type__from_string,
    KeySizeType_.c_tag: key_size_type__from_string,
    CipherData.c_tag: cipher_data_from_string,
    CipherDataType_.c_tag: cipher_data_type__from_string,
    CipherReference.c_tag: cipher_reference_from_string,
    CipherReferenceType_.c_tag: cipher_reference_type__from_string,
    TransformsType_.c_tag: transforms_type__from_string,
    EncryptedData.c_tag: encrypted_data_from_string,
    EncryptedDataType_.c_tag: encrypted_data_type__from_string,
    EncryptedKey.c_tag: encrypted_key_from_string,
    EncryptedKeyType_.c_tag: encrypted_key_type__from_string,
    AgreementMethod.c_tag: agreement_method_from_string,
    AgreementMethodType_.c_tag: agreement_method_type__from_string,
    ReferenceList.c_tag: reference_list_from_string,
    ReferenceType_.c_tag: reference_type__from_string,
    EncryptionProperties.c_tag: encryption_properties_from_string,
    EncryptionPropertiesType_.c_tag: encryption_properties_type__from_string,
    EncryptionProperty.c_tag: encryption_property_from_string,
    EncryptionPropertyType_.c_tag: encryption_property_type__from_string,
    CipherDataType_CipherValue.c_tag: cipher_data_type__cipher_value_from_string,
    AgreementMethodType_KA_Nonce.c_tag: agreement_method_type__k_a__nonce_from_string,
    AgreementMethodType_OriginatorKeyInfo.c_tag: agreement_method_type__originator_key_info_from_string,
    AgreementMethodType_RecipientKeyInfo.c_tag: agreement_method_type__recipient_key_info_from_string,
    EncryptionMethodType_KeySize.c_tag: encryption_method_type__key_size_from_string,
    EncryptionMethodType_OAEPparams.c_tag: encryption_method_type__oae_pparams_from_string,
    CipherReferenceType_Transforms.c_tag: cipher_reference_type__transforms_from_string,
    EncryptedType_EncryptionMethod.c_tag: encrypted_type__encryption_method_from_string,
    ReferenceList_DataReference.c_tag: reference_list__data_reference_from_string,
    ReferenceList_KeyReference.c_tag: reference_list__key_reference_from_string,
    EncryptedKeyType_CarriedKeyName.c_tag: encrypted_key_type__carried_key_name_from_string,
}

ELEMENT_BY_TAG = {
    'EncryptionMethodType': EncryptionMethodType_,
    'KeySizeType': KeySizeType_,
    'CipherData': CipherData,
    'CipherDataType': CipherDataType_,
    'CipherReference': CipherReference,
    'CipherReferenceType': CipherReferenceType_,
    'TransformsType': TransformsType_,
    'EncryptedData': EncryptedData,
    'EncryptedDataType': EncryptedDataType_,
    'EncryptedKey': EncryptedKey,
    'EncryptedKeyType': EncryptedKeyType_,
    'AgreementMethod': AgreementMethod,
    'AgreementMethodType': AgreementMethodType_,
    'ReferenceList': ReferenceList,
    'ReferenceType': ReferenceType_,
    'EncryptionProperties': EncryptionProperties,
    'EncryptionPropertiesType': EncryptionPropertiesType_,
    'EncryptionProperty': EncryptionProperty,
    'EncryptionPropertyType': EncryptionPropertyType_,
    'CipherValue': CipherDataType_CipherValue,
    'KA_Nonce': AgreementMethodType_KA_Nonce,
    'OriginatorKeyInfo': AgreementMethodType_OriginatorKeyInfo,
    'RecipientKeyInfo': AgreementMethodType_RecipientKeyInfo,
    'KeySize': EncryptionMethodType_KeySize,
    'OAEPparams': EncryptionMethodType_OAEPparams,
    'Transforms': CipherReferenceType_Transforms,
    'EncryptionMethod': EncryptedType_EncryptionMethod,
    'DataReference': ReferenceList_DataReference,
    'KeyReference': ReferenceList_KeyReference,
    'CarriedKeyName': EncryptedKeyType_CarriedKeyName,
    'EncryptedType': EncryptedType_,
}


def factory(tag, **kwargs):
    return ELEMENT_BY_TAG[tag](**kwargs)