diff options
Diffstat (limited to 'src/main/java/at/gv/util/xsd/saml')
26 files changed, 3264 insertions, 0 deletions
diff --git a/src/main/java/at/gv/util/xsd/saml/v2_0/assertion/ActionType.java b/src/main/java/at/gv/util/xsd/saml/v2_0/assertion/ActionType.java new file mode 100644 index 0000000..9adc425 --- /dev/null +++ b/src/main/java/at/gv/util/xsd/saml/v2_0/assertion/ActionType.java @@ -0,0 +1,89 @@ + +package at.gv.util.xsd.saml.v2_0.assertion; + +import javax.xml.bind.annotation.XmlAccessType; +import javax.xml.bind.annotation.XmlAccessorType; +import javax.xml.bind.annotation.XmlAttribute; +import javax.xml.bind.annotation.XmlSchemaType; +import javax.xml.bind.annotation.XmlType; +import javax.xml.bind.annotation.XmlValue; + + +/** + * <p>Java-Klasse für ActionType complex type. + * + * <p>Das folgende Schemafragment gibt den erwarteten Content an, der in dieser Klasse enthalten ist. + * + * <pre> + * <complexType name="ActionType"> + * <simpleContent> + * <extension base="<http://www.w3.org/2001/XMLSchema>string"> + * <attribute name="Namespace" use="required" type="{http://www.w3.org/2001/XMLSchema}anyURI" /> + * </extension> + * </simpleContent> + * </complexType> + * </pre> + * + * + */ +@XmlAccessorType(XmlAccessType.FIELD) +@XmlType(name = "ActionType", propOrder = { + "value" +}) +public class ActionType { + + @XmlValue + protected String value; + @XmlAttribute(name = "Namespace", required = true) + @XmlSchemaType(name = "anyURI") + protected String namespace; + + /** + * Ruft den Wert der value-Eigenschaft ab. + * + * @return + * possible object is + * {@link String } + * + */ + public String getValue() { + return value; + } + + /** + * Legt den Wert der value-Eigenschaft fest. + * + * @param value + * allowed object is + * {@link String } + * + */ + public void setValue(String value) { + this.value = value; + } + + /** + * Ruft den Wert der namespace-Eigenschaft ab. + * + * @return + * possible object is + * {@link String } + * + */ + public String getNamespace() { + return namespace; + } + + /** + * Legt den Wert der namespace-Eigenschaft fest. + * + * @param value + * allowed object is + * {@link String } + * + */ + public void setNamespace(String value) { + this.namespace = value; + } + +} diff --git a/src/main/java/at/gv/util/xsd/saml/v2_0/assertion/AdviceType.java b/src/main/java/at/gv/util/xsd/saml/v2_0/assertion/AdviceType.java new file mode 100644 index 0000000..c8e2de5 --- /dev/null +++ b/src/main/java/at/gv/util/xsd/saml/v2_0/assertion/AdviceType.java @@ -0,0 +1,88 @@ + +package at.gv.util.xsd.saml.v2_0.assertion; + +import java.util.ArrayList; +import java.util.List; +import javax.xml.bind.JAXBElement; +import javax.xml.bind.annotation.XmlAccessType; +import javax.xml.bind.annotation.XmlAccessorType; +import javax.xml.bind.annotation.XmlAnyElement; +import javax.xml.bind.annotation.XmlElementRef; +import javax.xml.bind.annotation.XmlElementRefs; +import javax.xml.bind.annotation.XmlType; +import org.w3c.dom.Element; + + +/** + * <p>Java-Klasse für AdviceType complex type. + * + * <p>Das folgende Schemafragment gibt den erwarteten Content an, der in dieser Klasse enthalten ist. + * + * <pre> + * <complexType name="AdviceType"> + * <complexContent> + * <restriction base="{http://www.w3.org/2001/XMLSchema}anyType"> + * <choice maxOccurs="unbounded" minOccurs="0"> + * <element ref="{urn:oasis:names:tc:SAML:2.0:assertion}AssertionIDRef"/> + * <element ref="{urn:oasis:names:tc:SAML:2.0:assertion}AssertionURIRef"/> + * <element ref="{urn:oasis:names:tc:SAML:2.0:assertion}Assertion"/> + * <element ref="{urn:oasis:names:tc:SAML:2.0:assertion}EncryptedAssertion"/> + * <any processContents='lax' namespace='##other'/> + * </choice> + * </restriction> + * </complexContent> + * </complexType> + * </pre> + * + * + */ +@XmlAccessorType(XmlAccessType.FIELD) +@XmlType(name = "AdviceType", propOrder = { + "assertionIDRefOrAssertionURIRefOrAssertion" +}) +public class AdviceType { + + @XmlElementRefs({ + @XmlElementRef(name = "AssertionIDRef", namespace = "urn:oasis:names:tc:SAML:2.0:assertion", type = JAXBElement.class, required = false), + @XmlElementRef(name = "AssertionURIRef", namespace = "urn:oasis:names:tc:SAML:2.0:assertion", type = JAXBElement.class, required = false), + @XmlElementRef(name = "EncryptedAssertion", namespace = "urn:oasis:names:tc:SAML:2.0:assertion", type = JAXBElement.class, required = false), + @XmlElementRef(name = "Assertion", namespace = "urn:oasis:names:tc:SAML:2.0:assertion", type = JAXBElement.class, required = false) + }) + @XmlAnyElement(lax = true) + protected List<Object> assertionIDRefOrAssertionURIRefOrAssertion; + + /** + * Gets the value of the assertionIDRefOrAssertionURIRefOrAssertion property. + * + * <p> + * This accessor method returns a reference to the live list, + * not a snapshot. Therefore any modification you make to the + * returned list will be present inside the JAXB object. + * This is why there is not a <CODE>set</CODE> method for the assertionIDRefOrAssertionURIRefOrAssertion property. + * + * <p> + * For example, to add a new item, do as follows: + * <pre> + * getAssertionIDRefOrAssertionURIRefOrAssertion().add(newItem); + * </pre> + * + * + * <p> + * Objects of the following type(s) are allowed in the list + * {@link JAXBElement }{@code <}{@link String }{@code >} + * {@link JAXBElement }{@code <}{@link String }{@code >} + * {@link JAXBElement }{@code <}{@link EncryptedElementType }{@code >} + * {@link Element } + * {@link Object } + * {@link JAXBElement }{@code <}{@link AssertionType }{@code >} + * + * + */ + public List<Object> getAssertionIDRefOrAssertionURIRefOrAssertion() { + if (assertionIDRefOrAssertionURIRefOrAssertion == null) { + assertionIDRefOrAssertionURIRefOrAssertion = new ArrayList<Object>(); + } + return this.assertionIDRefOrAssertionURIRefOrAssertion; + } + +} diff --git a/src/main/java/at/gv/util/xsd/saml/v2_0/assertion/AssertionType.java b/src/main/java/at/gv/util/xsd/saml/v2_0/assertion/AssertionType.java new file mode 100644 index 0000000..a2399e7 --- /dev/null +++ b/src/main/java/at/gv/util/xsd/saml/v2_0/assertion/AssertionType.java @@ -0,0 +1,315 @@ + +package at.gv.util.xsd.saml.v2_0.assertion; + +import java.util.ArrayList; +import java.util.List; +import javax.xml.bind.annotation.XmlAccessType; +import javax.xml.bind.annotation.XmlAccessorType; +import javax.xml.bind.annotation.XmlAttribute; +import javax.xml.bind.annotation.XmlElement; +import javax.xml.bind.annotation.XmlElements; +import javax.xml.bind.annotation.XmlID; +import javax.xml.bind.annotation.XmlSchemaType; +import javax.xml.bind.annotation.XmlType; +import javax.xml.bind.annotation.adapters.CollapsedStringAdapter; +import javax.xml.bind.annotation.adapters.XmlJavaTypeAdapter; +import javax.xml.datatype.XMLGregorianCalendar; +import at.gv.util.xsd.w3c_xmldsig.SignatureType; + + +/** + * <p>Java-Klasse für AssertionType complex type. + * + * <p>Das folgende Schemafragment gibt den erwarteten Content an, der in dieser Klasse enthalten ist. + * + * <pre> + * <complexType name="AssertionType"> + * <complexContent> + * <restriction base="{http://www.w3.org/2001/XMLSchema}anyType"> + * <sequence> + * <element ref="{urn:oasis:names:tc:SAML:2.0:assertion}Issuer"/> + * <element ref="{http://www.w3.org/2000/09/xmldsig#}Signature" minOccurs="0"/> + * <element ref="{urn:oasis:names:tc:SAML:2.0:assertion}Subject" minOccurs="0"/> + * <element ref="{urn:oasis:names:tc:SAML:2.0:assertion}Conditions" minOccurs="0"/> + * <element ref="{urn:oasis:names:tc:SAML:2.0:assertion}Advice" minOccurs="0"/> + * <choice maxOccurs="unbounded" minOccurs="0"> + * <element ref="{urn:oasis:names:tc:SAML:2.0:assertion}Statement"/> + * <element ref="{urn:oasis:names:tc:SAML:2.0:assertion}AuthnStatement"/> + * <element ref="{urn:oasis:names:tc:SAML:2.0:assertion}AuthzDecisionStatement"/> + * <element ref="{urn:oasis:names:tc:SAML:2.0:assertion}AttributeStatement"/> + * </choice> + * </sequence> + * <attribute name="Version" use="required" type="{http://www.w3.org/2001/XMLSchema}string" /> + * <attribute name="ID" use="required" type="{http://www.w3.org/2001/XMLSchema}ID" /> + * <attribute name="IssueInstant" use="required" type="{http://www.w3.org/2001/XMLSchema}dateTime" /> + * </restriction> + * </complexContent> + * </complexType> + * </pre> + * + * + */ +@XmlAccessorType(XmlAccessType.FIELD) +@XmlType(name = "AssertionType", propOrder = { + "issuer", + "signature", + "subject", + "conditions", + "advice", + "statementOrAuthnStatementOrAuthzDecisionStatement" +}) +public class AssertionType { + + @XmlElement(name = "Issuer", required = true) + protected NameIDType issuer; + @XmlElement(name = "Signature", namespace = "http://www.w3.org/2000/09/xmldsig#") + protected SignatureType signature; + @XmlElement(name = "Subject") + protected SubjectType subject; + @XmlElement(name = "Conditions") + protected ConditionsType conditions; + @XmlElement(name = "Advice") + protected AdviceType advice; + @XmlElements({ + @XmlElement(name = "Statement"), + @XmlElement(name = "AuthnStatement", type = AuthnStatementType.class), + @XmlElement(name = "AuthzDecisionStatement", type = AuthzDecisionStatementType.class), + @XmlElement(name = "AttributeStatement", type = AttributeStatementType.class) + }) + protected List<StatementAbstractType> statementOrAuthnStatementOrAuthzDecisionStatement; + @XmlAttribute(name = "Version", required = true) + protected String version; + @XmlAttribute(name = "ID", required = true) + @XmlJavaTypeAdapter(CollapsedStringAdapter.class) + @XmlID + @XmlSchemaType(name = "ID") + protected String id; + @XmlAttribute(name = "IssueInstant", required = true) + @XmlSchemaType(name = "dateTime") + protected XMLGregorianCalendar issueInstant; + + /** + * Ruft den Wert der issuer-Eigenschaft ab. + * + * @return + * possible object is + * {@link NameIDType } + * + */ + public NameIDType getIssuer() { + return issuer; + } + + /** + * Legt den Wert der issuer-Eigenschaft fest. + * + * @param value + * allowed object is + * {@link NameIDType } + * + */ + public void setIssuer(NameIDType value) { + this.issuer = value; + } + + /** + * Ruft den Wert der signature-Eigenschaft ab. + * + * @return + * possible object is + * {@link SignatureType } + * + */ + public SignatureType getSignature() { + return signature; + } + + /** + * Legt den Wert der signature-Eigenschaft fest. + * + * @param value + * allowed object is + * {@link SignatureType } + * + */ + public void setSignature(SignatureType value) { + this.signature = value; + } + + /** + * Ruft den Wert der subject-Eigenschaft ab. + * + * @return + * possible object is + * {@link SubjectType } + * + */ + public SubjectType getSubject() { + return subject; + } + + /** + * Legt den Wert der subject-Eigenschaft fest. + * + * @param value + * allowed object is + * {@link SubjectType } + * + */ + public void setSubject(SubjectType value) { + this.subject = value; + } + + /** + * Ruft den Wert der conditions-Eigenschaft ab. + * + * @return + * possible object is + * {@link ConditionsType } + * + */ + public ConditionsType getConditions() { + return conditions; + } + + /** + * Legt den Wert der conditions-Eigenschaft fest. + * + * @param value + * allowed object is + * {@link ConditionsType } + * + */ + public void setConditions(ConditionsType value) { + this.conditions = value; + } + + /** + * Ruft den Wert der advice-Eigenschaft ab. + * + * @return + * possible object is + * {@link AdviceType } + * + */ + public AdviceType getAdvice() { + return advice; + } + + /** + * Legt den Wert der advice-Eigenschaft fest. + * + * @param value + * allowed object is + * {@link AdviceType } + * + */ + public void setAdvice(AdviceType value) { + this.advice = value; + } + + /** + * Gets the value of the statementOrAuthnStatementOrAuthzDecisionStatement property. + * + * <p> + * This accessor method returns a reference to the live list, + * not a snapshot. Therefore any modification you make to the + * returned list will be present inside the JAXB object. + * This is why there is not a <CODE>set</CODE> method for the statementOrAuthnStatementOrAuthzDecisionStatement property. + * + * <p> + * For example, to add a new item, do as follows: + * <pre> + * getStatementOrAuthnStatementOrAuthzDecisionStatement().add(newItem); + * </pre> + * + * + * <p> + * Objects of the following type(s) are allowed in the list + * {@link StatementAbstractType } + * {@link AuthnStatementType } + * {@link AuthzDecisionStatementType } + * {@link AttributeStatementType } + * + * + */ + public List<StatementAbstractType> getStatementOrAuthnStatementOrAuthzDecisionStatement() { + if (statementOrAuthnStatementOrAuthzDecisionStatement == null) { + statementOrAuthnStatementOrAuthzDecisionStatement = new ArrayList<StatementAbstractType>(); + } + return this.statementOrAuthnStatementOrAuthzDecisionStatement; + } + + /** + * Ruft den Wert der version-Eigenschaft ab. + * + * @return + * possible object is + * {@link String } + * + */ + public String getVersion() { + return version; + } + + /** + * Legt den Wert der version-Eigenschaft fest. + * + * @param value + * allowed object is + * {@link String } + * + */ + public void setVersion(String value) { + this.version = value; + } + + /** + * Ruft den Wert der id-Eigenschaft ab. + * + * @return + * possible object is + * {@link String } + * + */ + public String getID() { + return id; + } + + /** + * Legt den Wert der id-Eigenschaft fest. + * + * @param value + * allowed object is + * {@link String } + * + */ + public void setID(String value) { + this.id = value; + } + + /** + * Ruft den Wert der issueInstant-Eigenschaft ab. + * + * @return + * possible object is + * {@link XMLGregorianCalendar } + * + */ + public XMLGregorianCalendar getIssueInstant() { + return issueInstant; + } + + /** + * Legt den Wert der issueInstant-Eigenschaft fest. + * + * @param value + * allowed object is + * {@link XMLGregorianCalendar } + * + */ + public void setIssueInstant(XMLGregorianCalendar value) { + this.issueInstant = value; + } + +} diff --git a/src/main/java/at/gv/util/xsd/saml/v2_0/assertion/AttributeStatementType.java b/src/main/java/at/gv/util/xsd/saml/v2_0/assertion/AttributeStatementType.java new file mode 100644 index 0000000..a21e072 --- /dev/null +++ b/src/main/java/at/gv/util/xsd/saml/v2_0/assertion/AttributeStatementType.java @@ -0,0 +1,77 @@ + +package at.gv.util.xsd.saml.v2_0.assertion; + +import java.util.ArrayList; +import java.util.List; +import javax.xml.bind.annotation.XmlAccessType; +import javax.xml.bind.annotation.XmlAccessorType; +import javax.xml.bind.annotation.XmlElement; +import javax.xml.bind.annotation.XmlElements; +import javax.xml.bind.annotation.XmlType; + + +/** + * <p>Java-Klasse für AttributeStatementType complex type. + * + * <p>Das folgende Schemafragment gibt den erwarteten Content an, der in dieser Klasse enthalten ist. + * + * <pre> + * <complexType name="AttributeStatementType"> + * <complexContent> + * <extension base="{urn:oasis:names:tc:SAML:2.0:assertion}StatementAbstractType"> + * <choice maxOccurs="unbounded"> + * <element ref="{urn:oasis:names:tc:SAML:2.0:assertion}Attribute"/> + * <element ref="{urn:oasis:names:tc:SAML:2.0:assertion}EncryptedAttribute"/> + * </choice> + * </extension> + * </complexContent> + * </complexType> + * </pre> + * + * + */ +@XmlAccessorType(XmlAccessType.FIELD) +@XmlType(name = "AttributeStatementType", propOrder = { + "attributeOrEncryptedAttribute" +}) +public class AttributeStatementType + extends StatementAbstractType +{ + + @XmlElements({ + @XmlElement(name = "Attribute", type = AttributeType.class), + @XmlElement(name = "EncryptedAttribute", type = EncryptedElementType.class) + }) + protected List<Object> attributeOrEncryptedAttribute; + + /** + * Gets the value of the attributeOrEncryptedAttribute property. + * + * <p> + * This accessor method returns a reference to the live list, + * not a snapshot. Therefore any modification you make to the + * returned list will be present inside the JAXB object. + * This is why there is not a <CODE>set</CODE> method for the attributeOrEncryptedAttribute property. + * + * <p> + * For example, to add a new item, do as follows: + * <pre> + * getAttributeOrEncryptedAttribute().add(newItem); + * </pre> + * + * + * <p> + * Objects of the following type(s) are allowed in the list + * {@link AttributeType } + * {@link EncryptedElementType } + * + * + */ + public List<Object> getAttributeOrEncryptedAttribute() { + if (attributeOrEncryptedAttribute == null) { + attributeOrEncryptedAttribute = new ArrayList<Object>(); + } + return this.attributeOrEncryptedAttribute; + } + +} diff --git a/src/main/java/at/gv/util/xsd/saml/v2_0/assertion/AttributeType.java b/src/main/java/at/gv/util/xsd/saml/v2_0/assertion/AttributeType.java new file mode 100644 index 0000000..949ce3e --- /dev/null +++ b/src/main/java/at/gv/util/xsd/saml/v2_0/assertion/AttributeType.java @@ -0,0 +1,178 @@ + +package at.gv.util.xsd.saml.v2_0.assertion; + +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import javax.xml.bind.annotation.XmlAccessType; +import javax.xml.bind.annotation.XmlAccessorType; +import javax.xml.bind.annotation.XmlAnyAttribute; +import javax.xml.bind.annotation.XmlAttribute; +import javax.xml.bind.annotation.XmlElement; +import javax.xml.bind.annotation.XmlSchemaType; +import javax.xml.bind.annotation.XmlType; +import javax.xml.namespace.QName; + + +/** + * <p>Java-Klasse für AttributeType complex type. + * + * <p>Das folgende Schemafragment gibt den erwarteten Content an, der in dieser Klasse enthalten ist. + * + * <pre> + * <complexType name="AttributeType"> + * <complexContent> + * <restriction base="{http://www.w3.org/2001/XMLSchema}anyType"> + * <sequence> + * <element ref="{urn:oasis:names:tc:SAML:2.0:assertion}AttributeValue" maxOccurs="unbounded" minOccurs="0"/> + * </sequence> + * <attribute name="Name" use="required" type="{http://www.w3.org/2001/XMLSchema}string" /> + * <attribute name="NameFormat" type="{http://www.w3.org/2001/XMLSchema}anyURI" /> + * <attribute name="FriendlyName" type="{http://www.w3.org/2001/XMLSchema}string" /> + * <anyAttribute processContents='lax' namespace='##other'/> + * </restriction> + * </complexContent> + * </complexType> + * </pre> + * + * + */ +@XmlAccessorType(XmlAccessType.FIELD) +@XmlType(name = "AttributeType", propOrder = { + "attributeValue" +}) +public class AttributeType { + + @XmlElement(name = "AttributeValue", nillable = true) + protected List<Object> attributeValue; + @XmlAttribute(name = "Name", required = true) + protected String name; + @XmlAttribute(name = "NameFormat") + @XmlSchemaType(name = "anyURI") + protected String nameFormat; + @XmlAttribute(name = "FriendlyName") + protected String friendlyName; + @XmlAnyAttribute + private Map<QName, String> otherAttributes = new HashMap<QName, String>(); + + /** + * Gets the value of the attributeValue property. + * + * <p> + * This accessor method returns a reference to the live list, + * not a snapshot. Therefore any modification you make to the + * returned list will be present inside the JAXB object. + * This is why there is not a <CODE>set</CODE> method for the attributeValue property. + * + * <p> + * For example, to add a new item, do as follows: + * <pre> + * getAttributeValue().add(newItem); + * </pre> + * + * + * <p> + * Objects of the following type(s) are allowed in the list + * {@link Object } + * + * + */ + public List<Object> getAttributeValue() { + if (attributeValue == null) { + attributeValue = new ArrayList<Object>(); + } + return this.attributeValue; + } + + /** + * Ruft den Wert der name-Eigenschaft ab. + * + * @return + * possible object is + * {@link String } + * + */ + public String getName() { + return name; + } + + /** + * Legt den Wert der name-Eigenschaft fest. + * + * @param value + * allowed object is + * {@link String } + * + */ + public void setName(String value) { + this.name = value; + } + + /** + * Ruft den Wert der nameFormat-Eigenschaft ab. + * + * @return + * possible object is + * {@link String } + * + */ + public String getNameFormat() { + return nameFormat; + } + + /** + * Legt den Wert der nameFormat-Eigenschaft fest. + * + * @param value + * allowed object is + * {@link String } + * + */ + public void setNameFormat(String value) { + this.nameFormat = value; + } + + /** + * Ruft den Wert der friendlyName-Eigenschaft ab. + * + * @return + * possible object is + * {@link String } + * + */ + public String getFriendlyName() { + return friendlyName; + } + + /** + * Legt den Wert der friendlyName-Eigenschaft fest. + * + * @param value + * allowed object is + * {@link String } + * + */ + public void setFriendlyName(String value) { + this.friendlyName = value; + } + + /** + * Gets a map that contains attributes that aren't bound to any typed property on this class. + * + * <p> + * the map is keyed by the name of the attribute and + * the value is the string value of the attribute. + * + * the map returned by this method is live, and you can add new attribute + * by updating the map directly. Because of this design, there's no setter. + * + * + * @return + * always non-null + */ + public Map<QName, String> getOtherAttributes() { + return otherAttributes; + } + +} diff --git a/src/main/java/at/gv/util/xsd/saml/v2_0/assertion/AudienceRestrictionType.java b/src/main/java/at/gv/util/xsd/saml/v2_0/assertion/AudienceRestrictionType.java new file mode 100644 index 0000000..b47be07 --- /dev/null +++ b/src/main/java/at/gv/util/xsd/saml/v2_0/assertion/AudienceRestrictionType.java @@ -0,0 +1,73 @@ + +package at.gv.util.xsd.saml.v2_0.assertion; + +import java.util.ArrayList; +import java.util.List; +import javax.xml.bind.annotation.XmlAccessType; +import javax.xml.bind.annotation.XmlAccessorType; +import javax.xml.bind.annotation.XmlElement; +import javax.xml.bind.annotation.XmlSchemaType; +import javax.xml.bind.annotation.XmlType; + + +/** + * <p>Java-Klasse für AudienceRestrictionType complex type. + * + * <p>Das folgende Schemafragment gibt den erwarteten Content an, der in dieser Klasse enthalten ist. + * + * <pre> + * <complexType name="AudienceRestrictionType"> + * <complexContent> + * <extension base="{urn:oasis:names:tc:SAML:2.0:assertion}ConditionAbstractType"> + * <sequence> + * <element ref="{urn:oasis:names:tc:SAML:2.0:assertion}Audience" maxOccurs="unbounded"/> + * </sequence> + * </extension> + * </complexContent> + * </complexType> + * </pre> + * + * + */ +@XmlAccessorType(XmlAccessType.FIELD) +@XmlType(name = "AudienceRestrictionType", propOrder = { + "audience" +}) +public class AudienceRestrictionType + extends ConditionAbstractType +{ + + @XmlElement(name = "Audience", required = true) + @XmlSchemaType(name = "anyURI") + protected List<String> audience; + + /** + * Gets the value of the audience property. + * + * <p> + * This accessor method returns a reference to the live list, + * not a snapshot. Therefore any modification you make to the + * returned list will be present inside the JAXB object. + * This is why there is not a <CODE>set</CODE> method for the audience property. + * + * <p> + * For example, to add a new item, do as follows: + * <pre> + * getAudience().add(newItem); + * </pre> + * + * + * <p> + * Objects of the following type(s) are allowed in the list + * {@link String } + * + * + */ + public List<String> getAudience() { + if (audience == null) { + audience = new ArrayList<String>(); + } + return this.audience; + } + +} diff --git a/src/main/java/at/gv/util/xsd/saml/v2_0/assertion/AuthnContextType.java b/src/main/java/at/gv/util/xsd/saml/v2_0/assertion/AuthnContextType.java new file mode 100644 index 0000000..765d36d --- /dev/null +++ b/src/main/java/at/gv/util/xsd/saml/v2_0/assertion/AuthnContextType.java @@ -0,0 +1,102 @@ + +package at.gv.util.xsd.saml.v2_0.assertion; + +import java.util.ArrayList; +import java.util.List; +import javax.xml.bind.JAXBElement; +import javax.xml.bind.annotation.XmlAccessType; +import javax.xml.bind.annotation.XmlAccessorType; +import javax.xml.bind.annotation.XmlElementRef; +import javax.xml.bind.annotation.XmlElementRefs; +import javax.xml.bind.annotation.XmlType; + + +/** + * <p>Java-Klasse für AuthnContextType complex type. + * + * <p>Das folgende Schemafragment gibt den erwarteten Content an, der in dieser Klasse enthalten ist. + * + * <pre> + * <complexType name="AuthnContextType"> + * <complexContent> + * <restriction base="{http://www.w3.org/2001/XMLSchema}anyType"> + * <sequence> + * <choice> + * <sequence> + * <element ref="{urn:oasis:names:tc:SAML:2.0:assertion}AuthnContextClassRef"/> + * <choice minOccurs="0"> + * <element ref="{urn:oasis:names:tc:SAML:2.0:assertion}AuthnContextDecl"/> + * <element ref="{urn:oasis:names:tc:SAML:2.0:assertion}AuthnContextDeclRef"/> + * </choice> + * </sequence> + * <choice> + * <element ref="{urn:oasis:names:tc:SAML:2.0:assertion}AuthnContextDecl"/> + * <element ref="{urn:oasis:names:tc:SAML:2.0:assertion}AuthnContextDeclRef"/> + * </choice> + * </choice> + * <element ref="{urn:oasis:names:tc:SAML:2.0:assertion}AuthenticatingAuthority" maxOccurs="unbounded" minOccurs="0"/> + * </sequence> + * </restriction> + * </complexContent> + * </complexType> + * </pre> + * + * + */ +@XmlAccessorType(XmlAccessType.FIELD) +@XmlType(name = "AuthnContextType", propOrder = { + "content" +}) +public class AuthnContextType { + + @XmlElementRefs({ + @XmlElementRef(name = "AuthnContextClassRef", namespace = "urn:oasis:names:tc:SAML:2.0:assertion", type = JAXBElement.class, required = false), + @XmlElementRef(name = "AuthnContextDeclRef", namespace = "urn:oasis:names:tc:SAML:2.0:assertion", type = JAXBElement.class, required = false), + @XmlElementRef(name = "AuthnContextDecl", namespace = "urn:oasis:names:tc:SAML:2.0:assertion", type = JAXBElement.class, required = false), + @XmlElementRef(name = "AuthenticatingAuthority", namespace = "urn:oasis:names:tc:SAML:2.0:assertion", type = JAXBElement.class, required = false) + }) + protected List<JAXBElement<?>> content; + + /** + * Ruft das restliche Contentmodell ab. + * + * <p> + * Sie rufen diese "catch-all"-Eigenschaft aus folgendem Grund ab: + * Der Feldname "AuthnContextDecl" wird von zwei verschiedenen Teilen eines Schemas verwendet. Siehe: + * Zeile 0 von https://docs.oasis-open.org/security/saml/v2.0/saml-schema-assertion-2.0.xsd + * Zeile 0 von https://docs.oasis-open.org/security/saml/v2.0/saml-schema-assertion-2.0.xsd + * <p> + * Um diese Eigenschaft zu entfernen, wenden Sie eine Eigenschaftenanpassung für eine + * der beiden folgenden Deklarationen an, um deren Namen zu ändern: + * Gets the value of the content property. + * + * <p> + * This accessor method returns a reference to the live list, + * not a snapshot. Therefore any modification you make to the + * returned list will be present inside the JAXB object. + * This is why there is not a <CODE>set</CODE> method for the content property. + * + * <p> + * For example, to add a new item, do as follows: + * <pre> + * getContent().add(newItem); + * </pre> + * + * + * <p> + * Objects of the following type(s) are allowed in the list + * {@link JAXBElement }{@code <}{@link String }{@code >} + * {@link JAXBElement }{@code <}{@link String }{@code >} + * {@link JAXBElement }{@code <}{@link Object }{@code >} + * {@link JAXBElement }{@code <}{@link String }{@code >} + * + * + */ + public List<JAXBElement<?>> getContent() { + if (content == null) { + content = new ArrayList<JAXBElement<?>>(); + } + return this.content; + } + +} diff --git a/src/main/java/at/gv/util/xsd/saml/v2_0/assertion/AuthnStatementType.java b/src/main/java/at/gv/util/xsd/saml/v2_0/assertion/AuthnStatementType.java new file mode 100644 index 0000000..b3b4872 --- /dev/null +++ b/src/main/java/at/gv/util/xsd/saml/v2_0/assertion/AuthnStatementType.java @@ -0,0 +1,178 @@ + +package at.gv.util.xsd.saml.v2_0.assertion; + +import javax.xml.bind.annotation.XmlAccessType; +import javax.xml.bind.annotation.XmlAccessorType; +import javax.xml.bind.annotation.XmlAttribute; +import javax.xml.bind.annotation.XmlElement; +import javax.xml.bind.annotation.XmlSchemaType; +import javax.xml.bind.annotation.XmlType; +import javax.xml.datatype.XMLGregorianCalendar; + + +/** + * <p>Java-Klasse für AuthnStatementType complex type. + * + * <p>Das folgende Schemafragment gibt den erwarteten Content an, der in dieser Klasse enthalten ist. + * + * <pre> + * <complexType name="AuthnStatementType"> + * <complexContent> + * <extension base="{urn:oasis:names:tc:SAML:2.0:assertion}StatementAbstractType"> + * <sequence> + * <element ref="{urn:oasis:names:tc:SAML:2.0:assertion}SubjectLocality" minOccurs="0"/> + * <element ref="{urn:oasis:names:tc:SAML:2.0:assertion}AuthnContext"/> + * </sequence> + * <attribute name="AuthnInstant" use="required" type="{http://www.w3.org/2001/XMLSchema}dateTime" /> + * <attribute name="SessionIndex" type="{http://www.w3.org/2001/XMLSchema}string" /> + * <attribute name="SessionNotOnOrAfter" type="{http://www.w3.org/2001/XMLSchema}dateTime" /> + * </extension> + * </complexContent> + * </complexType> + * </pre> + * + * + */ +@XmlAccessorType(XmlAccessType.FIELD) +@XmlType(name = "AuthnStatementType", propOrder = { + "subjectLocality", + "authnContext" +}) +public class AuthnStatementType + extends StatementAbstractType +{ + + @XmlElement(name = "SubjectLocality") + protected SubjectLocalityType subjectLocality; + @XmlElement(name = "AuthnContext", required = true) + protected AuthnContextType authnContext; + @XmlAttribute(name = "AuthnInstant", required = true) + @XmlSchemaType(name = "dateTime") + protected XMLGregorianCalendar authnInstant; + @XmlAttribute(name = "SessionIndex") + protected String sessionIndex; + @XmlAttribute(name = "SessionNotOnOrAfter") + @XmlSchemaType(name = "dateTime") + protected XMLGregorianCalendar sessionNotOnOrAfter; + + /** + * Ruft den Wert der subjectLocality-Eigenschaft ab. + * + * @return + * possible object is + * {@link SubjectLocalityType } + * + */ + public SubjectLocalityType getSubjectLocality() { + return subjectLocality; + } + + /** + * Legt den Wert der subjectLocality-Eigenschaft fest. + * + * @param value + * allowed object is + * {@link SubjectLocalityType } + * + */ + public void setSubjectLocality(SubjectLocalityType value) { + this.subjectLocality = value; + } + + /** + * Ruft den Wert der authnContext-Eigenschaft ab. + * + * @return + * possible object is + * {@link AuthnContextType } + * + */ + public AuthnContextType getAuthnContext() { + return authnContext; + } + + /** + * Legt den Wert der authnContext-Eigenschaft fest. + * + * @param value + * allowed object is + * {@link AuthnContextType } + * + */ + public void setAuthnContext(AuthnContextType value) { + this.authnContext = value; + } + + /** + * Ruft den Wert der authnInstant-Eigenschaft ab. + * + * @return + * possible object is + * {@link XMLGregorianCalendar } + * + */ + public XMLGregorianCalendar getAuthnInstant() { + return authnInstant; + } + + /** + * Legt den Wert der authnInstant-Eigenschaft fest. + * + * @param value + * allowed object is + * {@link XMLGregorianCalendar } + * + */ + public void setAuthnInstant(XMLGregorianCalendar value) { + this.authnInstant = value; + } + + /** + * Ruft den Wert der sessionIndex-Eigenschaft ab. + * + * @return + * possible object is + * {@link String } + * + */ + public String getSessionIndex() { + return sessionIndex; + } + + /** + * Legt den Wert der sessionIndex-Eigenschaft fest. + * + * @param value + * allowed object is + * {@link String } + * + */ + public void setSessionIndex(String value) { + this.sessionIndex = value; + } + + /** + * Ruft den Wert der sessionNotOnOrAfter-Eigenschaft ab. + * + * @return + * possible object is + * {@link XMLGregorianCalendar } + * + */ + public XMLGregorianCalendar getSessionNotOnOrAfter() { + return sessionNotOnOrAfter; + } + + /** + * Legt den Wert der sessionNotOnOrAfter-Eigenschaft fest. + * + * @param value + * allowed object is + * {@link XMLGregorianCalendar } + * + */ + public void setSessionNotOnOrAfter(XMLGregorianCalendar value) { + this.sessionNotOnOrAfter = value; + } + +} diff --git a/src/main/java/at/gv/util/xsd/saml/v2_0/assertion/AuthzDecisionStatementType.java b/src/main/java/at/gv/util/xsd/saml/v2_0/assertion/AuthzDecisionStatementType.java new file mode 100644 index 0000000..6de2d2a --- /dev/null +++ b/src/main/java/at/gv/util/xsd/saml/v2_0/assertion/AuthzDecisionStatementType.java @@ -0,0 +1,156 @@ + +package at.gv.util.xsd.saml.v2_0.assertion; + +import java.util.ArrayList; +import java.util.List; +import javax.xml.bind.annotation.XmlAccessType; +import javax.xml.bind.annotation.XmlAccessorType; +import javax.xml.bind.annotation.XmlAttribute; +import javax.xml.bind.annotation.XmlElement; +import javax.xml.bind.annotation.XmlSchemaType; +import javax.xml.bind.annotation.XmlType; + + +/** + * <p>Java-Klasse für AuthzDecisionStatementType complex type. + * + * <p>Das folgende Schemafragment gibt den erwarteten Content an, der in dieser Klasse enthalten ist. + * + * <pre> + * <complexType name="AuthzDecisionStatementType"> + * <complexContent> + * <extension base="{urn:oasis:names:tc:SAML:2.0:assertion}StatementAbstractType"> + * <sequence> + * <element ref="{urn:oasis:names:tc:SAML:2.0:assertion}Action" maxOccurs="unbounded"/> + * <element ref="{urn:oasis:names:tc:SAML:2.0:assertion}Evidence" minOccurs="0"/> + * </sequence> + * <attribute name="Resource" use="required" type="{http://www.w3.org/2001/XMLSchema}anyURI" /> + * <attribute name="Decision" use="required" type="{urn:oasis:names:tc:SAML:2.0:assertion}DecisionType" /> + * </extension> + * </complexContent> + * </complexType> + * </pre> + * + * + */ +@XmlAccessorType(XmlAccessType.FIELD) +@XmlType(name = "AuthzDecisionStatementType", propOrder = { + "action", + "evidence" +}) +public class AuthzDecisionStatementType + extends StatementAbstractType +{ + + @XmlElement(name = "Action", required = true) + protected List<ActionType> action; + @XmlElement(name = "Evidence") + protected EvidenceType evidence; + @XmlAttribute(name = "Resource", required = true) + @XmlSchemaType(name = "anyURI") + protected String resource; + @XmlAttribute(name = "Decision", required = true) + protected DecisionType decision; + + /** + * Gets the value of the action property. + * + * <p> + * This accessor method returns a reference to the live list, + * not a snapshot. Therefore any modification you make to the + * returned list will be present inside the JAXB object. + * This is why there is not a <CODE>set</CODE> method for the action property. + * + * <p> + * For example, to add a new item, do as follows: + * <pre> + * getAction().add(newItem); + * </pre> + * + * + * <p> + * Objects of the following type(s) are allowed in the list + * {@link ActionType } + * + * + */ + public List<ActionType> getAction() { + if (action == null) { + action = new ArrayList<ActionType>(); + } + return this.action; + } + + /** + * Ruft den Wert der evidence-Eigenschaft ab. + * + * @return + * possible object is + * {@link EvidenceType } + * + */ + public EvidenceType getEvidence() { + return evidence; + } + + /** + * Legt den Wert der evidence-Eigenschaft fest. + * + * @param value + * allowed object is + * {@link EvidenceType } + * + */ + public void setEvidence(EvidenceType value) { + this.evidence = value; + } + + /** + * Ruft den Wert der resource-Eigenschaft ab. + * + * @return + * possible object is + * {@link String } + * + */ + public String getResource() { + return resource; + } + + /** + * Legt den Wert der resource-Eigenschaft fest. + * + * @param value + * allowed object is + * {@link String } + * + */ + public void setResource(String value) { + this.resource = value; + } + + /** + * Ruft den Wert der decision-Eigenschaft ab. + * + * @return + * possible object is + * {@link DecisionType } + * + */ + public DecisionType getDecision() { + return decision; + } + + /** + * Legt den Wert der decision-Eigenschaft fest. + * + * @param value + * allowed object is + * {@link DecisionType } + * + */ + public void setDecision(DecisionType value) { + this.decision = value; + } + +} diff --git a/src/main/java/at/gv/util/xsd/saml/v2_0/assertion/BaseIDAbstractType.java b/src/main/java/at/gv/util/xsd/saml/v2_0/assertion/BaseIDAbstractType.java new file mode 100644 index 0000000..08d9fad --- /dev/null +++ b/src/main/java/at/gv/util/xsd/saml/v2_0/assertion/BaseIDAbstractType.java @@ -0,0 +1,84 @@ + +package at.gv.util.xsd.saml.v2_0.assertion; + +import javax.xml.bind.annotation.XmlAccessType; +import javax.xml.bind.annotation.XmlAccessorType; +import javax.xml.bind.annotation.XmlAttribute; +import javax.xml.bind.annotation.XmlType; + + +/** + * <p>Java-Klasse für BaseIDAbstractType complex type. + * + * <p>Das folgende Schemafragment gibt den erwarteten Content an, der in dieser Klasse enthalten ist. + * + * <pre> + * <complexType name="BaseIDAbstractType"> + * <complexContent> + * <restriction base="{http://www.w3.org/2001/XMLSchema}anyType"> + * <attGroup ref="{urn:oasis:names:tc:SAML:2.0:assertion}IDNameQualifiers"/> + * </restriction> + * </complexContent> + * </complexType> + * </pre> + * + * + */ +@XmlAccessorType(XmlAccessType.FIELD) +@XmlType(name = "BaseIDAbstractType") +public abstract class BaseIDAbstractType { + + @XmlAttribute(name = "NameQualifier") + protected String nameQualifier; + @XmlAttribute(name = "SPNameQualifier") + protected String spNameQualifier; + + /** + * Ruft den Wert der nameQualifier-Eigenschaft ab. + * + * @return + * possible object is + * {@link String } + * + */ + public String getNameQualifier() { + return nameQualifier; + } + + /** + * Legt den Wert der nameQualifier-Eigenschaft fest. + * + * @param value + * allowed object is + * {@link String } + * + */ + public void setNameQualifier(String value) { + this.nameQualifier = value; + } + + /** + * Ruft den Wert der spNameQualifier-Eigenschaft ab. + * + * @return + * possible object is + * {@link String } + * + */ + public String getSPNameQualifier() { + return spNameQualifier; + } + + /** + * Legt den Wert der spNameQualifier-Eigenschaft fest. + * + * @param value + * allowed object is + * {@link String } + * + */ + public void setSPNameQualifier(String value) { + this.spNameQualifier = value; + } + +} diff --git a/src/main/java/at/gv/util/xsd/saml/v2_0/assertion/ConditionAbstractType.java b/src/main/java/at/gv/util/xsd/saml/v2_0/assertion/ConditionAbstractType.java new file mode 100644 index 0000000..34728dc --- /dev/null +++ b/src/main/java/at/gv/util/xsd/saml/v2_0/assertion/ConditionAbstractType.java @@ -0,0 +1,36 @@ + +package at.gv.util.xsd.saml.v2_0.assertion; + +import javax.xml.bind.annotation.XmlAccessType; +import javax.xml.bind.annotation.XmlAccessorType; +import javax.xml.bind.annotation.XmlSeeAlso; +import javax.xml.bind.annotation.XmlType; + + +/** + * <p>Java-Klasse für ConditionAbstractType complex type. + * + * <p>Das folgende Schemafragment gibt den erwarteten Content an, der in dieser Klasse enthalten ist. + * + * <pre> + * <complexType name="ConditionAbstractType"> + * <complexContent> + * <restriction base="{http://www.w3.org/2001/XMLSchema}anyType"> + * </restriction> + * </complexContent> + * </complexType> + * </pre> + * + * + */ +@XmlAccessorType(XmlAccessType.FIELD) +@XmlType(name = "ConditionAbstractType") +@XmlSeeAlso({ + AudienceRestrictionType.class, + OneTimeUseType.class, + ProxyRestrictionType.class +}) +public abstract class ConditionAbstractType { + + +} diff --git a/src/main/java/at/gv/util/xsd/saml/v2_0/assertion/ConditionsType.java b/src/main/java/at/gv/util/xsd/saml/v2_0/assertion/ConditionsType.java new file mode 100644 index 0000000..f1ccbf8 --- /dev/null +++ b/src/main/java/at/gv/util/xsd/saml/v2_0/assertion/ConditionsType.java @@ -0,0 +1,140 @@ + +package at.gv.util.xsd.saml.v2_0.assertion; + +import java.util.ArrayList; +import java.util.List; +import javax.xml.bind.annotation.XmlAccessType; +import javax.xml.bind.annotation.XmlAccessorType; +import javax.xml.bind.annotation.XmlAttribute; +import javax.xml.bind.annotation.XmlElement; +import javax.xml.bind.annotation.XmlElements; +import javax.xml.bind.annotation.XmlSchemaType; +import javax.xml.bind.annotation.XmlType; +import javax.xml.datatype.XMLGregorianCalendar; + + +/** + * <p>Java-Klasse für ConditionsType complex type. + * + * <p>Das folgende Schemafragment gibt den erwarteten Content an, der in dieser Klasse enthalten ist. + * + * <pre> + * <complexType name="ConditionsType"> + * <complexContent> + * <restriction base="{http://www.w3.org/2001/XMLSchema}anyType"> + * <choice maxOccurs="unbounded" minOccurs="0"> + * <element ref="{urn:oasis:names:tc:SAML:2.0:assertion}Condition"/> + * <element ref="{urn:oasis:names:tc:SAML:2.0:assertion}AudienceRestriction"/> + * <element ref="{urn:oasis:names:tc:SAML:2.0:assertion}OneTimeUse"/> + * <element ref="{urn:oasis:names:tc:SAML:2.0:assertion}ProxyRestriction"/> + * </choice> + * <attribute name="NotBefore" type="{http://www.w3.org/2001/XMLSchema}dateTime" /> + * <attribute name="NotOnOrAfter" type="{http://www.w3.org/2001/XMLSchema}dateTime" /> + * </restriction> + * </complexContent> + * </complexType> + * </pre> + * + * + */ +@XmlAccessorType(XmlAccessType.FIELD) +@XmlType(name = "ConditionsType", propOrder = { + "conditionOrAudienceRestrictionOrOneTimeUse" +}) +public class ConditionsType { + + @XmlElements({ + @XmlElement(name = "Condition"), + @XmlElement(name = "AudienceRestriction", type = AudienceRestrictionType.class), + @XmlElement(name = "OneTimeUse", type = OneTimeUseType.class), + @XmlElement(name = "ProxyRestriction", type = ProxyRestrictionType.class) + }) + protected List<ConditionAbstractType> conditionOrAudienceRestrictionOrOneTimeUse; + @XmlAttribute(name = "NotBefore") + @XmlSchemaType(name = "dateTime") + protected XMLGregorianCalendar notBefore; + @XmlAttribute(name = "NotOnOrAfter") + @XmlSchemaType(name = "dateTime") + protected XMLGregorianCalendar notOnOrAfter; + + /** + * Gets the value of the conditionOrAudienceRestrictionOrOneTimeUse property. + * + * <p> + * This accessor method returns a reference to the live list, + * not a snapshot. Therefore any modification you make to the + * returned list will be present inside the JAXB object. + * This is why there is not a <CODE>set</CODE> method for the conditionOrAudienceRestrictionOrOneTimeUse property. + * + * <p> + * For example, to add a new item, do as follows: + * <pre> + * getConditionOrAudienceRestrictionOrOneTimeUse().add(newItem); + * </pre> + * + * + * <p> + * Objects of the following type(s) are allowed in the list + * {@link ConditionAbstractType } + * {@link AudienceRestrictionType } + * {@link OneTimeUseType } + * {@link ProxyRestrictionType } + * + * + */ + public List<ConditionAbstractType> getConditionOrAudienceRestrictionOrOneTimeUse() { + if (conditionOrAudienceRestrictionOrOneTimeUse == null) { + conditionOrAudienceRestrictionOrOneTimeUse = new ArrayList<ConditionAbstractType>(); + } + return this.conditionOrAudienceRestrictionOrOneTimeUse; + } + + /** + * Ruft den Wert der notBefore-Eigenschaft ab. + * + * @return + * possible object is + * {@link XMLGregorianCalendar } + * + */ + public XMLGregorianCalendar getNotBefore() { + return notBefore; + } + + /** + * Legt den Wert der notBefore-Eigenschaft fest. + * + * @param value + * allowed object is + * {@link XMLGregorianCalendar } + * + */ + public void setNotBefore(XMLGregorianCalendar value) { + this.notBefore = value; + } + + /** + * Ruft den Wert der notOnOrAfter-Eigenschaft ab. + * + * @return + * possible object is + * {@link XMLGregorianCalendar } + * + */ + public XMLGregorianCalendar getNotOnOrAfter() { + return notOnOrAfter; + } + + /** + * Legt den Wert der notOnOrAfter-Eigenschaft fest. + * + * @param value + * allowed object is + * {@link XMLGregorianCalendar } + * + */ + public void setNotOnOrAfter(XMLGregorianCalendar value) { + this.notOnOrAfter = value; + } + +} diff --git a/src/main/java/at/gv/util/xsd/saml/v2_0/assertion/DecisionType.java b/src/main/java/at/gv/util/xsd/saml/v2_0/assertion/DecisionType.java new file mode 100644 index 0000000..43b659f --- /dev/null +++ b/src/main/java/at/gv/util/xsd/saml/v2_0/assertion/DecisionType.java @@ -0,0 +1,54 @@ + +package at.gv.util.xsd.saml.v2_0.assertion; + +import javax.xml.bind.annotation.XmlEnum; +import javax.xml.bind.annotation.XmlEnumValue; +import javax.xml.bind.annotation.XmlType; + + +/** + * <p>Java-Klasse für DecisionType. + * + * <p>Das folgende Schemafragment gibt den erwarteten Content an, der in dieser Klasse enthalten ist. + * <p> + * <pre> + * <simpleType name="DecisionType"> + * <restriction base="{http://www.w3.org/2001/XMLSchema}string"> + * <enumeration value="Permit"/> + * <enumeration value="Deny"/> + * <enumeration value="Indeterminate"/> + * </restriction> + * </simpleType> + * </pre> + * + */ +@XmlType(name = "DecisionType") +@XmlEnum +public enum DecisionType { + + @XmlEnumValue("Permit") + PERMIT("Permit"), + @XmlEnumValue("Deny") + DENY("Deny"), + @XmlEnumValue("Indeterminate") + INDETERMINATE("Indeterminate"); + private final String value; + + DecisionType(String v) { + value = v; + } + + public String value() { + return value; + } + + public static DecisionType fromValue(String v) { + for (DecisionType c: DecisionType.values()) { + if (c.value.equals(v)) { + return c; + } + } + throw new IllegalArgumentException(v); + } + +} diff --git a/src/main/java/at/gv/util/xsd/saml/v2_0/assertion/EncryptedElementType.java b/src/main/java/at/gv/util/xsd/saml/v2_0/assertion/EncryptedElementType.java new file mode 100644 index 0000000..1c1ebaf --- /dev/null +++ b/src/main/java/at/gv/util/xsd/saml/v2_0/assertion/EncryptedElementType.java @@ -0,0 +1,99 @@ + +package at.gv.util.xsd.saml.v2_0.assertion; + +import java.util.ArrayList; +import java.util.List; +import javax.xml.bind.annotation.XmlAccessType; +import javax.xml.bind.annotation.XmlAccessorType; +import javax.xml.bind.annotation.XmlElement; +import javax.xml.bind.annotation.XmlType; +import at.gv.util.xsd.w3c_xmlenc.EncryptedDataType; +import at.gv.util.xsd.w3c_xmlenc.EncryptedKeyType; + + +/** + * <p>Java-Klasse für EncryptedElementType complex type. + * + * <p>Das folgende Schemafragment gibt den erwarteten Content an, der in dieser Klasse enthalten ist. + * + * <pre> + * <complexType name="EncryptedElementType"> + * <complexContent> + * <restriction base="{http://www.w3.org/2001/XMLSchema}anyType"> + * <sequence> + * <element ref="{http://www.w3.org/2001/04/xmlenc#}EncryptedData"/> + * <element ref="{http://www.w3.org/2001/04/xmlenc#}EncryptedKey" maxOccurs="unbounded" minOccurs="0"/> + * </sequence> + * </restriction> + * </complexContent> + * </complexType> + * </pre> + * + * + */ +@XmlAccessorType(XmlAccessType.FIELD) +@XmlType(name = "EncryptedElementType", propOrder = { + "encryptedData", + "encryptedKey" +}) +public class EncryptedElementType { + + @XmlElement(name = "EncryptedData", namespace = "http://www.w3.org/2001/04/xmlenc#", required = true) + protected EncryptedDataType encryptedData; + @XmlElement(name = "EncryptedKey", namespace = "http://www.w3.org/2001/04/xmlenc#") + protected List<EncryptedKeyType> encryptedKey; + + /** + * Ruft den Wert der encryptedData-Eigenschaft ab. + * + * @return + * possible object is + * {@link EncryptedDataType } + * + */ + public EncryptedDataType getEncryptedData() { + return encryptedData; + } + + /** + * Legt den Wert der encryptedData-Eigenschaft fest. + * + * @param value + * allowed object is + * {@link EncryptedDataType } + * + */ + public void setEncryptedData(EncryptedDataType value) { + this.encryptedData = value; + } + + /** + * Gets the value of the encryptedKey property. + * + * <p> + * This accessor method returns a reference to the live list, + * not a snapshot. Therefore any modification you make to the + * returned list will be present inside the JAXB object. + * This is why there is not a <CODE>set</CODE> method for the encryptedKey property. + * + * <p> + * For example, to add a new item, do as follows: + * <pre> + * getEncryptedKey().add(newItem); + * </pre> + * + * + * <p> + * Objects of the following type(s) are allowed in the list + * {@link EncryptedKeyType } + * + * + */ + public List<EncryptedKeyType> getEncryptedKey() { + if (encryptedKey == null) { + encryptedKey = new ArrayList<EncryptedKeyType>(); + } + return this.encryptedKey; + } + +} diff --git a/src/main/java/at/gv/util/xsd/saml/v2_0/assertion/EvidenceType.java b/src/main/java/at/gv/util/xsd/saml/v2_0/assertion/EvidenceType.java new file mode 100644 index 0000000..a6b9446 --- /dev/null +++ b/src/main/java/at/gv/util/xsd/saml/v2_0/assertion/EvidenceType.java @@ -0,0 +1,82 @@ + +package at.gv.util.xsd.saml.v2_0.assertion; + +import java.util.ArrayList; +import java.util.List; +import javax.xml.bind.JAXBElement; +import javax.xml.bind.annotation.XmlAccessType; +import javax.xml.bind.annotation.XmlAccessorType; +import javax.xml.bind.annotation.XmlElementRef; +import javax.xml.bind.annotation.XmlElementRefs; +import javax.xml.bind.annotation.XmlType; + + +/** + * <p>Java-Klasse für EvidenceType complex type. + * + * <p>Das folgende Schemafragment gibt den erwarteten Content an, der in dieser Klasse enthalten ist. + * + * <pre> + * <complexType name="EvidenceType"> + * <complexContent> + * <restriction base="{http://www.w3.org/2001/XMLSchema}anyType"> + * <choice maxOccurs="unbounded"> + * <element ref="{urn:oasis:names:tc:SAML:2.0:assertion}AssertionIDRef"/> + * <element ref="{urn:oasis:names:tc:SAML:2.0:assertion}AssertionURIRef"/> + * <element ref="{urn:oasis:names:tc:SAML:2.0:assertion}Assertion"/> + * <element ref="{urn:oasis:names:tc:SAML:2.0:assertion}EncryptedAssertion"/> + * </choice> + * </restriction> + * </complexContent> + * </complexType> + * </pre> + * + * + */ +@XmlAccessorType(XmlAccessType.FIELD) +@XmlType(name = "EvidenceType", propOrder = { + "assertionIDRefOrAssertionURIRefOrAssertion" +}) +public class EvidenceType { + + @XmlElementRefs({ + @XmlElementRef(name = "AssertionIDRef", namespace = "urn:oasis:names:tc:SAML:2.0:assertion", type = JAXBElement.class, required = false), + @XmlElementRef(name = "AssertionURIRef", namespace = "urn:oasis:names:tc:SAML:2.0:assertion", type = JAXBElement.class, required = false), + @XmlElementRef(name = "EncryptedAssertion", namespace = "urn:oasis:names:tc:SAML:2.0:assertion", type = JAXBElement.class, required = false), + @XmlElementRef(name = "Assertion", namespace = "urn:oasis:names:tc:SAML:2.0:assertion", type = JAXBElement.class, required = false) + }) + protected List<JAXBElement<?>> assertionIDRefOrAssertionURIRefOrAssertion; + + /** + * Gets the value of the assertionIDRefOrAssertionURIRefOrAssertion property. + * + * <p> + * This accessor method returns a reference to the live list, + * not a snapshot. Therefore any modification you make to the + * returned list will be present inside the JAXB object. + * This is why there is not a <CODE>set</CODE> method for the assertionIDRefOrAssertionURIRefOrAssertion property. + * + * <p> + * For example, to add a new item, do as follows: + * <pre> + * getAssertionIDRefOrAssertionURIRefOrAssertion().add(newItem); + * </pre> + * + * + * <p> + * Objects of the following type(s) are allowed in the list + * {@link JAXBElement }{@code <}{@link String }{@code >} + * {@link JAXBElement }{@code <}{@link String }{@code >} + * {@link JAXBElement }{@code <}{@link EncryptedElementType }{@code >} + * {@link JAXBElement }{@code <}{@link AssertionType }{@code >} + * + * + */ + public List<JAXBElement<?>> getAssertionIDRefOrAssertionURIRefOrAssertion() { + if (assertionIDRefOrAssertionURIRefOrAssertion == null) { + assertionIDRefOrAssertionURIRefOrAssertion = new ArrayList<JAXBElement<?>>(); + } + return this.assertionIDRefOrAssertionURIRefOrAssertion; + } + +} diff --git a/src/main/java/at/gv/util/xsd/saml/v2_0/assertion/KeyInfoConfirmationDataType.java b/src/main/java/at/gv/util/xsd/saml/v2_0/assertion/KeyInfoConfirmationDataType.java new file mode 100644 index 0000000..b863e31 --- /dev/null +++ b/src/main/java/at/gv/util/xsd/saml/v2_0/assertion/KeyInfoConfirmationDataType.java @@ -0,0 +1,35 @@ + +package at.gv.util.xsd.saml.v2_0.assertion; + +import javax.xml.bind.annotation.XmlAccessType; +import javax.xml.bind.annotation.XmlAccessorType; +import javax.xml.bind.annotation.XmlType; + + +/** + * <p>Java-Klasse für KeyInfoConfirmationDataType complex type. + * + * <p>Das folgende Schemafragment gibt den erwarteten Content an, der in dieser Klasse enthalten ist. + * + * <pre> + * <complexType name="KeyInfoConfirmationDataType"> + * <complexContent> + * <restriction base="{urn:oasis:names:tc:SAML:2.0:assertion}SubjectConfirmationDataType"> + * <sequence> + * <element ref="{http://www.w3.org/2000/09/xmldsig#}KeyInfo" maxOccurs="unbounded"/> + * </sequence> + * </restriction> + * </complexContent> + * </complexType> + * </pre> + * + * + */ +@XmlAccessorType(XmlAccessType.FIELD) +@XmlType(name = "KeyInfoConfirmationDataType") +public class KeyInfoConfirmationDataType + extends SubjectConfirmationDataType +{ + + +} diff --git a/src/main/java/at/gv/util/xsd/saml/v2_0/assertion/NameIDType.java b/src/main/java/at/gv/util/xsd/saml/v2_0/assertion/NameIDType.java new file mode 100644 index 0000000..ca64b53 --- /dev/null +++ b/src/main/java/at/gv/util/xsd/saml/v2_0/assertion/NameIDType.java @@ -0,0 +1,169 @@ + +package at.gv.util.xsd.saml.v2_0.assertion; + +import javax.xml.bind.annotation.XmlAccessType; +import javax.xml.bind.annotation.XmlAccessorType; +import javax.xml.bind.annotation.XmlAttribute; +import javax.xml.bind.annotation.XmlSchemaType; +import javax.xml.bind.annotation.XmlType; +import javax.xml.bind.annotation.XmlValue; + + +/** + * <p>Java-Klasse für NameIDType complex type. + * + * <p>Das folgende Schemafragment gibt den erwarteten Content an, der in dieser Klasse enthalten ist. + * + * <pre> + * <complexType name="NameIDType"> + * <simpleContent> + * <extension base="<http://www.w3.org/2001/XMLSchema>string"> + * <attGroup ref="{urn:oasis:names:tc:SAML:2.0:assertion}IDNameQualifiers"/> + * <attribute name="Format" type="{http://www.w3.org/2001/XMLSchema}anyURI" /> + * <attribute name="SPProvidedID" type="{http://www.w3.org/2001/XMLSchema}string" /> + * </extension> + * </simpleContent> + * </complexType> + * </pre> + * + * + */ +@XmlAccessorType(XmlAccessType.FIELD) +@XmlType(name = "NameIDType", propOrder = { + "value" +}) +public class NameIDType { + + @XmlValue + protected String value; + @XmlAttribute(name = "Format") + @XmlSchemaType(name = "anyURI") + protected String format; + @XmlAttribute(name = "SPProvidedID") + protected String spProvidedID; + @XmlAttribute(name = "NameQualifier") + protected String nameQualifier; + @XmlAttribute(name = "SPNameQualifier") + protected String spNameQualifier; + + /** + * Ruft den Wert der value-Eigenschaft ab. + * + * @return + * possible object is + * {@link String } + * + */ + public String getValue() { + return value; + } + + /** + * Legt den Wert der value-Eigenschaft fest. + * + * @param value + * allowed object is + * {@link String } + * + */ + public void setValue(String value) { + this.value = value; + } + + /** + * Ruft den Wert der format-Eigenschaft ab. + * + * @return + * possible object is + * {@link String } + * + */ + public String getFormat() { + return format; + } + + /** + * Legt den Wert der format-Eigenschaft fest. + * + * @param value + * allowed object is + * {@link String } + * + */ + public void setFormat(String value) { + this.format = value; + } + + /** + * Ruft den Wert der spProvidedID-Eigenschaft ab. + * + * @return + * possible object is + * {@link String } + * + */ + public String getSPProvidedID() { + return spProvidedID; + } + + /** + * Legt den Wert der spProvidedID-Eigenschaft fest. + * + * @param value + * allowed object is + * {@link String } + * + */ + public void setSPProvidedID(String value) { + this.spProvidedID = value; + } + + /** + * Ruft den Wert der nameQualifier-Eigenschaft ab. + * + * @return + * possible object is + * {@link String } + * + */ + public String getNameQualifier() { + return nameQualifier; + } + + /** + * Legt den Wert der nameQualifier-Eigenschaft fest. + * + * @param value + * allowed object is + * {@link String } + * + */ + public void setNameQualifier(String value) { + this.nameQualifier = value; + } + + /** + * Ruft den Wert der spNameQualifier-Eigenschaft ab. + * + * @return + * possible object is + * {@link String } + * + */ + public String getSPNameQualifier() { + return spNameQualifier; + } + + /** + * Legt den Wert der spNameQualifier-Eigenschaft fest. + * + * @param value + * allowed object is + * {@link String } + * + */ + public void setSPNameQualifier(String value) { + this.spNameQualifier = value; + } + +} diff --git a/src/main/java/at/gv/util/xsd/saml/v2_0/assertion/ObjectFactory.java b/src/main/java/at/gv/util/xsd/saml/v2_0/assertion/ObjectFactory.java new file mode 100644 index 0000000..cebe5e1 --- /dev/null +++ b/src/main/java/at/gv/util/xsd/saml/v2_0/assertion/ObjectFactory.java @@ -0,0 +1,528 @@ + +package at.gv.util.xsd.saml.v2_0.assertion; + +import javax.xml.bind.JAXBElement; +import javax.xml.bind.annotation.XmlElementDecl; +import javax.xml.bind.annotation.XmlRegistry; +import javax.xml.bind.annotation.adapters.CollapsedStringAdapter; +import javax.xml.bind.annotation.adapters.XmlJavaTypeAdapter; +import javax.xml.namespace.QName; + + +/** + * This object contains factory methods for each + * Java content interface and Java element interface + * generated in the at.gv.util.xsd.saml.v2_0.assertion package. + * <p>An ObjectFactory allows you to programatically + * construct new instances of the Java representation + * for XML content. The Java representation of XML + * content can consist of schema derived interfaces + * and classes representing the binding of schema + * type definitions, element declarations and model + * groups. Factory methods for each of these are + * provided in this class. + * + */ +@XmlRegistry +public class ObjectFactory { + + private final static QName _BaseID_QNAME = new QName("urn:oasis:names:tc:SAML:2.0:assertion", "BaseID"); + private final static QName _NameID_QNAME = new QName("urn:oasis:names:tc:SAML:2.0:assertion", "NameID"); + private final static QName _EncryptedID_QNAME = new QName("urn:oasis:names:tc:SAML:2.0:assertion", "EncryptedID"); + private final static QName _Issuer_QNAME = new QName("urn:oasis:names:tc:SAML:2.0:assertion", "Issuer"); + private final static QName _AssertionIDRef_QNAME = new QName("urn:oasis:names:tc:SAML:2.0:assertion", "AssertionIDRef"); + private final static QName _AssertionURIRef_QNAME = new QName("urn:oasis:names:tc:SAML:2.0:assertion", "AssertionURIRef"); + private final static QName _Assertion_QNAME = new QName("urn:oasis:names:tc:SAML:2.0:assertion", "Assertion"); + private final static QName _Subject_QNAME = new QName("urn:oasis:names:tc:SAML:2.0:assertion", "Subject"); + private final static QName _SubjectConfirmation_QNAME = new QName("urn:oasis:names:tc:SAML:2.0:assertion", "SubjectConfirmation"); + private final static QName _SubjectConfirmationData_QNAME = new QName("urn:oasis:names:tc:SAML:2.0:assertion", "SubjectConfirmationData"); + private final static QName _Conditions_QNAME = new QName("urn:oasis:names:tc:SAML:2.0:assertion", "Conditions"); + private final static QName _Condition_QNAME = new QName("urn:oasis:names:tc:SAML:2.0:assertion", "Condition"); + private final static QName _AudienceRestriction_QNAME = new QName("urn:oasis:names:tc:SAML:2.0:assertion", "AudienceRestriction"); + private final static QName _Audience_QNAME = new QName("urn:oasis:names:tc:SAML:2.0:assertion", "Audience"); + private final static QName _OneTimeUse_QNAME = new QName("urn:oasis:names:tc:SAML:2.0:assertion", "OneTimeUse"); + private final static QName _ProxyRestriction_QNAME = new QName("urn:oasis:names:tc:SAML:2.0:assertion", "ProxyRestriction"); + private final static QName _Advice_QNAME = new QName("urn:oasis:names:tc:SAML:2.0:assertion", "Advice"); + private final static QName _EncryptedAssertion_QNAME = new QName("urn:oasis:names:tc:SAML:2.0:assertion", "EncryptedAssertion"); + private final static QName _Statement_QNAME = new QName("urn:oasis:names:tc:SAML:2.0:assertion", "Statement"); + private final static QName _AuthnStatement_QNAME = new QName("urn:oasis:names:tc:SAML:2.0:assertion", "AuthnStatement"); + private final static QName _SubjectLocality_QNAME = new QName("urn:oasis:names:tc:SAML:2.0:assertion", "SubjectLocality"); + private final static QName _AuthnContext_QNAME = new QName("urn:oasis:names:tc:SAML:2.0:assertion", "AuthnContext"); + private final static QName _AuthnContextClassRef_QNAME = new QName("urn:oasis:names:tc:SAML:2.0:assertion", "AuthnContextClassRef"); + private final static QName _AuthnContextDeclRef_QNAME = new QName("urn:oasis:names:tc:SAML:2.0:assertion", "AuthnContextDeclRef"); + private final static QName _AuthnContextDecl_QNAME = new QName("urn:oasis:names:tc:SAML:2.0:assertion", "AuthnContextDecl"); + private final static QName _AuthenticatingAuthority_QNAME = new QName("urn:oasis:names:tc:SAML:2.0:assertion", "AuthenticatingAuthority"); + private final static QName _AuthzDecisionStatement_QNAME = new QName("urn:oasis:names:tc:SAML:2.0:assertion", "AuthzDecisionStatement"); + private final static QName _Action_QNAME = new QName("urn:oasis:names:tc:SAML:2.0:assertion", "Action"); + private final static QName _Evidence_QNAME = new QName("urn:oasis:names:tc:SAML:2.0:assertion", "Evidence"); + private final static QName _AttributeStatement_QNAME = new QName("urn:oasis:names:tc:SAML:2.0:assertion", "AttributeStatement"); + private final static QName _Attribute_QNAME = new QName("urn:oasis:names:tc:SAML:2.0:assertion", "Attribute"); + private final static QName _AttributeValue_QNAME = new QName("urn:oasis:names:tc:SAML:2.0:assertion", "AttributeValue"); + private final static QName _EncryptedAttribute_QNAME = new QName("urn:oasis:names:tc:SAML:2.0:assertion", "EncryptedAttribute"); + + /** + * Create a new ObjectFactory that can be used to create new instances of schema derived classes for package: at.gv.util.xsd.saml.v2_0.assertion + * + */ + public ObjectFactory() { + } + + /** + * Create an instance of {@link NameIDType } + * + */ + public NameIDType createNameIDType() { + return new NameIDType(); + } + + /** + * Create an instance of {@link EncryptedElementType } + * + */ + public EncryptedElementType createEncryptedElementType() { + return new EncryptedElementType(); + } + + /** + * Create an instance of {@link AssertionType } + * + */ + public AssertionType createAssertionType() { + return new AssertionType(); + } + + /** + * Create an instance of {@link SubjectType } + * + */ + public SubjectType createSubjectType() { + return new SubjectType(); + } + + /** + * Create an instance of {@link SubjectConfirmationType } + * + */ + public SubjectConfirmationType createSubjectConfirmationType() { + return new SubjectConfirmationType(); + } + + /** + * Create an instance of {@link SubjectConfirmationDataType } + * + */ + public SubjectConfirmationDataType createSubjectConfirmationDataType() { + return new SubjectConfirmationDataType(); + } + + /** + * Create an instance of {@link ConditionsType } + * + */ + public ConditionsType createConditionsType() { + return new ConditionsType(); + } + + /** + * Create an instance of {@link AudienceRestrictionType } + * + */ + public AudienceRestrictionType createAudienceRestrictionType() { + return new AudienceRestrictionType(); + } + + /** + * Create an instance of {@link OneTimeUseType } + * + */ + public OneTimeUseType createOneTimeUseType() { + return new OneTimeUseType(); + } + + /** + * Create an instance of {@link ProxyRestrictionType } + * + */ + public ProxyRestrictionType createProxyRestrictionType() { + return new ProxyRestrictionType(); + } + + /** + * Create an instance of {@link AdviceType } + * + */ + public AdviceType createAdviceType() { + return new AdviceType(); + } + + /** + * Create an instance of {@link AuthnStatementType } + * + */ + public AuthnStatementType createAuthnStatementType() { + return new AuthnStatementType(); + } + + /** + * Create an instance of {@link SubjectLocalityType } + * + */ + public SubjectLocalityType createSubjectLocalityType() { + return new SubjectLocalityType(); + } + + /** + * Create an instance of {@link AuthnContextType } + * + */ + public AuthnContextType createAuthnContextType() { + return new AuthnContextType(); + } + + /** + * Create an instance of {@link AuthzDecisionStatementType } + * + */ + public AuthzDecisionStatementType createAuthzDecisionStatementType() { + return new AuthzDecisionStatementType(); + } + + /** + * Create an instance of {@link ActionType } + * + */ + public ActionType createActionType() { + return new ActionType(); + } + + /** + * Create an instance of {@link EvidenceType } + * + */ + public EvidenceType createEvidenceType() { + return new EvidenceType(); + } + + /** + * Create an instance of {@link AttributeStatementType } + * + */ + public AttributeStatementType createAttributeStatementType() { + return new AttributeStatementType(); + } + + /** + * Create an instance of {@link AttributeType } + * + */ + public AttributeType createAttributeType() { + return new AttributeType(); + } + + /** + * Create an instance of {@link KeyInfoConfirmationDataType } + * + */ + public KeyInfoConfirmationDataType createKeyInfoConfirmationDataType() { + return new KeyInfoConfirmationDataType(); + } + + /** + * Create an instance of {@link JAXBElement }{@code <}{@link BaseIDAbstractType }{@code >}} + * + */ + @XmlElementDecl(namespace = "urn:oasis:names:tc:SAML:2.0:assertion", name = "BaseID") + public JAXBElement<BaseIDAbstractType> createBaseID(BaseIDAbstractType value) { + return new JAXBElement<BaseIDAbstractType>(_BaseID_QNAME, BaseIDAbstractType.class, null, value); + } + + /** + * Create an instance of {@link JAXBElement }{@code <}{@link NameIDType }{@code >}} + * + */ + @XmlElementDecl(namespace = "urn:oasis:names:tc:SAML:2.0:assertion", name = "NameID") + public JAXBElement<NameIDType> createNameID(NameIDType value) { + return new JAXBElement<NameIDType>(_NameID_QNAME, NameIDType.class, null, value); + } + + /** + * Create an instance of {@link JAXBElement }{@code <}{@link EncryptedElementType }{@code >}} + * + */ + @XmlElementDecl(namespace = "urn:oasis:names:tc:SAML:2.0:assertion", name = "EncryptedID") + public JAXBElement<EncryptedElementType> createEncryptedID(EncryptedElementType value) { + return new JAXBElement<EncryptedElementType>(_EncryptedID_QNAME, EncryptedElementType.class, null, value); + } + + /** + * Create an instance of {@link JAXBElement }{@code <}{@link NameIDType }{@code >}} + * + */ + @XmlElementDecl(namespace = "urn:oasis:names:tc:SAML:2.0:assertion", name = "Issuer") + public JAXBElement<NameIDType> createIssuer(NameIDType value) { + return new JAXBElement<NameIDType>(_Issuer_QNAME, NameIDType.class, null, value); + } + + /** + * Create an instance of {@link JAXBElement }{@code <}{@link String }{@code >}} + * + */ + @XmlElementDecl(namespace = "urn:oasis:names:tc:SAML:2.0:assertion", name = "AssertionIDRef") + @XmlJavaTypeAdapter(CollapsedStringAdapter.class) + public JAXBElement<String> createAssertionIDRef(String value) { + return new JAXBElement<String>(_AssertionIDRef_QNAME, String.class, null, value); + } + + /** + * Create an instance of {@link JAXBElement }{@code <}{@link String }{@code >}} + * + */ + @XmlElementDecl(namespace = "urn:oasis:names:tc:SAML:2.0:assertion", name = "AssertionURIRef") + public JAXBElement<String> createAssertionURIRef(String value) { + return new JAXBElement<String>(_AssertionURIRef_QNAME, String.class, null, value); + } + + /** + * Create an instance of {@link JAXBElement }{@code <}{@link AssertionType }{@code >}} + * + */ + @XmlElementDecl(namespace = "urn:oasis:names:tc:SAML:2.0:assertion", name = "Assertion") + public JAXBElement<AssertionType> createAssertion(AssertionType value) { + return new JAXBElement<AssertionType>(_Assertion_QNAME, AssertionType.class, null, value); + } + + /** + * Create an instance of {@link JAXBElement }{@code <}{@link SubjectType }{@code >}} + * + */ + @XmlElementDecl(namespace = "urn:oasis:names:tc:SAML:2.0:assertion", name = "Subject") + public JAXBElement<SubjectType> createSubject(SubjectType value) { + return new JAXBElement<SubjectType>(_Subject_QNAME, SubjectType.class, null, value); + } + + /** + * Create an instance of {@link JAXBElement }{@code <}{@link SubjectConfirmationType }{@code >}} + * + */ + @XmlElementDecl(namespace = "urn:oasis:names:tc:SAML:2.0:assertion", name = "SubjectConfirmation") + public JAXBElement<SubjectConfirmationType> createSubjectConfirmation(SubjectConfirmationType value) { + return new JAXBElement<SubjectConfirmationType>(_SubjectConfirmation_QNAME, SubjectConfirmationType.class, null, value); + } + + /** + * Create an instance of {@link JAXBElement }{@code <}{@link SubjectConfirmationDataType }{@code >}} + * + */ + @XmlElementDecl(namespace = "urn:oasis:names:tc:SAML:2.0:assertion", name = "SubjectConfirmationData") + public JAXBElement<SubjectConfirmationDataType> createSubjectConfirmationData(SubjectConfirmationDataType value) { + return new JAXBElement<SubjectConfirmationDataType>(_SubjectConfirmationData_QNAME, SubjectConfirmationDataType.class, null, value); + } + + /** + * Create an instance of {@link JAXBElement }{@code <}{@link ConditionsType }{@code >}} + * + */ + @XmlElementDecl(namespace = "urn:oasis:names:tc:SAML:2.0:assertion", name = "Conditions") + public JAXBElement<ConditionsType> createConditions(ConditionsType value) { + return new JAXBElement<ConditionsType>(_Conditions_QNAME, ConditionsType.class, null, value); + } + + /** + * Create an instance of {@link JAXBElement }{@code <}{@link ConditionAbstractType }{@code >}} + * + */ + @XmlElementDecl(namespace = "urn:oasis:names:tc:SAML:2.0:assertion", name = "Condition") + public JAXBElement<ConditionAbstractType> createCondition(ConditionAbstractType value) { + return new JAXBElement<ConditionAbstractType>(_Condition_QNAME, ConditionAbstractType.class, null, value); + } + + /** + * Create an instance of {@link JAXBElement }{@code <}{@link AudienceRestrictionType }{@code >}} + * + */ + @XmlElementDecl(namespace = "urn:oasis:names:tc:SAML:2.0:assertion", name = "AudienceRestriction") + public JAXBElement<AudienceRestrictionType> createAudienceRestriction(AudienceRestrictionType value) { + return new JAXBElement<AudienceRestrictionType>(_AudienceRestriction_QNAME, AudienceRestrictionType.class, null, value); + } + + /** + * Create an instance of {@link JAXBElement }{@code <}{@link String }{@code >}} + * + */ + @XmlElementDecl(namespace = "urn:oasis:names:tc:SAML:2.0:assertion", name = "Audience") + public JAXBElement<String> createAudience(String value) { + return new JAXBElement<String>(_Audience_QNAME, String.class, null, value); + } + + /** + * Create an instance of {@link JAXBElement }{@code <}{@link OneTimeUseType }{@code >}} + * + */ + @XmlElementDecl(namespace = "urn:oasis:names:tc:SAML:2.0:assertion", name = "OneTimeUse") + public JAXBElement<OneTimeUseType> createOneTimeUse(OneTimeUseType value) { + return new JAXBElement<OneTimeUseType>(_OneTimeUse_QNAME, OneTimeUseType.class, null, value); + } + + /** + * Create an instance of {@link JAXBElement }{@code <}{@link ProxyRestrictionType }{@code >}} + * + */ + @XmlElementDecl(namespace = "urn:oasis:names:tc:SAML:2.0:assertion", name = "ProxyRestriction") + public JAXBElement<ProxyRestrictionType> createProxyRestriction(ProxyRestrictionType value) { + return new JAXBElement<ProxyRestrictionType>(_ProxyRestriction_QNAME, ProxyRestrictionType.class, null, value); + } + + /** + * Create an instance of {@link JAXBElement }{@code <}{@link AdviceType }{@code >}} + * + */ + @XmlElementDecl(namespace = "urn:oasis:names:tc:SAML:2.0:assertion", name = "Advice") + public JAXBElement<AdviceType> createAdvice(AdviceType value) { + return new JAXBElement<AdviceType>(_Advice_QNAME, AdviceType.class, null, value); + } + + /** + * Create an instance of {@link JAXBElement }{@code <}{@link EncryptedElementType }{@code >}} + * + */ + @XmlElementDecl(namespace = "urn:oasis:names:tc:SAML:2.0:assertion", name = "EncryptedAssertion") + public JAXBElement<EncryptedElementType> createEncryptedAssertion(EncryptedElementType value) { + return new JAXBElement<EncryptedElementType>(_EncryptedAssertion_QNAME, EncryptedElementType.class, null, value); + } + + /** + * Create an instance of {@link JAXBElement }{@code <}{@link StatementAbstractType }{@code >}} + * + */ + @XmlElementDecl(namespace = "urn:oasis:names:tc:SAML:2.0:assertion", name = "Statement") + public JAXBElement<StatementAbstractType> createStatement(StatementAbstractType value) { + return new JAXBElement<StatementAbstractType>(_Statement_QNAME, StatementAbstractType.class, null, value); + } + + /** + * Create an instance of {@link JAXBElement }{@code <}{@link AuthnStatementType }{@code >}} + * + */ + @XmlElementDecl(namespace = "urn:oasis:names:tc:SAML:2.0:assertion", name = "AuthnStatement") + public JAXBElement<AuthnStatementType> createAuthnStatement(AuthnStatementType value) { + return new JAXBElement<AuthnStatementType>(_AuthnStatement_QNAME, AuthnStatementType.class, null, value); + } + + /** + * Create an instance of {@link JAXBElement }{@code <}{@link SubjectLocalityType }{@code >}} + * + */ + @XmlElementDecl(namespace = "urn:oasis:names:tc:SAML:2.0:assertion", name = "SubjectLocality") + public JAXBElement<SubjectLocalityType> createSubjectLocality(SubjectLocalityType value) { + return new JAXBElement<SubjectLocalityType>(_SubjectLocality_QNAME, SubjectLocalityType.class, null, value); + } + + /** + * Create an instance of {@link JAXBElement }{@code <}{@link AuthnContextType }{@code >}} + * + */ + @XmlElementDecl(namespace = "urn:oasis:names:tc:SAML:2.0:assertion", name = "AuthnContext") + public JAXBElement<AuthnContextType> createAuthnContext(AuthnContextType value) { + return new JAXBElement<AuthnContextType>(_AuthnContext_QNAME, AuthnContextType.class, null, value); + } + + /** + * Create an instance of {@link JAXBElement }{@code <}{@link String }{@code >}} + * + */ + @XmlElementDecl(namespace = "urn:oasis:names:tc:SAML:2.0:assertion", name = "AuthnContextClassRef") + public JAXBElement<String> createAuthnContextClassRef(String value) { + return new JAXBElement<String>(_AuthnContextClassRef_QNAME, String.class, null, value); + } + + /** + * Create an instance of {@link JAXBElement }{@code <}{@link String }{@code >}} + * + */ + @XmlElementDecl(namespace = "urn:oasis:names:tc:SAML:2.0:assertion", name = "AuthnContextDeclRef") + public JAXBElement<String> createAuthnContextDeclRef(String value) { + return new JAXBElement<String>(_AuthnContextDeclRef_QNAME, String.class, null, value); + } + + /** + * Create an instance of {@link JAXBElement }{@code <}{@link Object }{@code >}} + * + */ + @XmlElementDecl(namespace = "urn:oasis:names:tc:SAML:2.0:assertion", name = "AuthnContextDecl") + public JAXBElement<Object> createAuthnContextDecl(Object value) { + return new JAXBElement<Object>(_AuthnContextDecl_QNAME, Object.class, null, value); + } + + /** + * Create an instance of {@link JAXBElement }{@code <}{@link String }{@code >}} + * + */ + @XmlElementDecl(namespace = "urn:oasis:names:tc:SAML:2.0:assertion", name = "AuthenticatingAuthority") + public JAXBElement<String> createAuthenticatingAuthority(String value) { + return new JAXBElement<String>(_AuthenticatingAuthority_QNAME, String.class, null, value); + } + + /** + * Create an instance of {@link JAXBElement }{@code <}{@link AuthzDecisionStatementType }{@code >}} + * + */ + @XmlElementDecl(namespace = "urn:oasis:names:tc:SAML:2.0:assertion", name = "AuthzDecisionStatement") + public JAXBElement<AuthzDecisionStatementType> createAuthzDecisionStatement(AuthzDecisionStatementType value) { + return new JAXBElement<AuthzDecisionStatementType>(_AuthzDecisionStatement_QNAME, AuthzDecisionStatementType.class, null, value); + } + + /** + * Create an instance of {@link JAXBElement }{@code <}{@link ActionType }{@code >}} + * + */ + @XmlElementDecl(namespace = "urn:oasis:names:tc:SAML:2.0:assertion", name = "Action") + public JAXBElement<ActionType> createAction(ActionType value) { + return new JAXBElement<ActionType>(_Action_QNAME, ActionType.class, null, value); + } + + /** + * Create an instance of {@link JAXBElement }{@code <}{@link EvidenceType }{@code >}} + * + */ + @XmlElementDecl(namespace = "urn:oasis:names:tc:SAML:2.0:assertion", name = "Evidence") + public JAXBElement<EvidenceType> createEvidence(EvidenceType value) { + return new JAXBElement<EvidenceType>(_Evidence_QNAME, EvidenceType.class, null, value); + } + + /** + * Create an instance of {@link JAXBElement }{@code <}{@link AttributeStatementType }{@code >}} + * + */ + @XmlElementDecl(namespace = "urn:oasis:names:tc:SAML:2.0:assertion", name = "AttributeStatement") + public JAXBElement<AttributeStatementType> createAttributeStatement(AttributeStatementType value) { + return new JAXBElement<AttributeStatementType>(_AttributeStatement_QNAME, AttributeStatementType.class, null, value); + } + + /** + * Create an instance of {@link JAXBElement }{@code <}{@link AttributeType }{@code >}} + * + */ + @XmlElementDecl(namespace = "urn:oasis:names:tc:SAML:2.0:assertion", name = "Attribute") + public JAXBElement<AttributeType> createAttribute(AttributeType value) { + return new JAXBElement<AttributeType>(_Attribute_QNAME, AttributeType.class, null, value); + } + + /** + * Create an instance of {@link JAXBElement }{@code <}{@link Object }{@code >}} + * + */ + @XmlElementDecl(namespace = "urn:oasis:names:tc:SAML:2.0:assertion", name = "AttributeValue") + public JAXBElement<Object> createAttributeValue(Object value) { + return new JAXBElement<Object>(_AttributeValue_QNAME, Object.class, null, value); + } + + /** + * Create an instance of {@link JAXBElement }{@code <}{@link EncryptedElementType }{@code >}} + * + */ + @XmlElementDecl(namespace = "urn:oasis:names:tc:SAML:2.0:assertion", name = "EncryptedAttribute") + public JAXBElement<EncryptedElementType> createEncryptedAttribute(EncryptedElementType value) { + return new JAXBElement<EncryptedElementType>(_EncryptedAttribute_QNAME, EncryptedElementType.class, null, value); + } + +} diff --git a/src/main/java/at/gv/util/xsd/saml/v2_0/assertion/OneTimeUseType.java b/src/main/java/at/gv/util/xsd/saml/v2_0/assertion/OneTimeUseType.java new file mode 100644 index 0000000..9d3b193 --- /dev/null +++ b/src/main/java/at/gv/util/xsd/saml/v2_0/assertion/OneTimeUseType.java @@ -0,0 +1,32 @@ + +package at.gv.util.xsd.saml.v2_0.assertion; + +import javax.xml.bind.annotation.XmlAccessType; +import javax.xml.bind.annotation.XmlAccessorType; +import javax.xml.bind.annotation.XmlType; + + +/** + * <p>Java-Klasse für OneTimeUseType complex type. + * + * <p>Das folgende Schemafragment gibt den erwarteten Content an, der in dieser Klasse enthalten ist. + * + * <pre> + * <complexType name="OneTimeUseType"> + * <complexContent> + * <extension base="{urn:oasis:names:tc:SAML:2.0:assertion}ConditionAbstractType"> + * </extension> + * </complexContent> + * </complexType> + * </pre> + * + * + */ +@XmlAccessorType(XmlAccessType.FIELD) +@XmlType(name = "OneTimeUseType") +public class OneTimeUseType + extends ConditionAbstractType +{ + + +} diff --git a/src/main/java/at/gv/util/xsd/saml/v2_0/assertion/ProxyRestrictionType.java b/src/main/java/at/gv/util/xsd/saml/v2_0/assertion/ProxyRestrictionType.java new file mode 100644 index 0000000..e928f89 --- /dev/null +++ b/src/main/java/at/gv/util/xsd/saml/v2_0/assertion/ProxyRestrictionType.java @@ -0,0 +1,103 @@ + +package at.gv.util.xsd.saml.v2_0.assertion; + +import java.math.BigInteger; +import java.util.ArrayList; +import java.util.List; +import javax.xml.bind.annotation.XmlAccessType; +import javax.xml.bind.annotation.XmlAccessorType; +import javax.xml.bind.annotation.XmlAttribute; +import javax.xml.bind.annotation.XmlElement; +import javax.xml.bind.annotation.XmlSchemaType; +import javax.xml.bind.annotation.XmlType; + + +/** + * <p>Java-Klasse für ProxyRestrictionType complex type. + * + * <p>Das folgende Schemafragment gibt den erwarteten Content an, der in dieser Klasse enthalten ist. + * + * <pre> + * <complexType name="ProxyRestrictionType"> + * <complexContent> + * <extension base="{urn:oasis:names:tc:SAML:2.0:assertion}ConditionAbstractType"> + * <sequence> + * <element ref="{urn:oasis:names:tc:SAML:2.0:assertion}Audience" maxOccurs="unbounded" minOccurs="0"/> + * </sequence> + * <attribute name="Count" type="{http://www.w3.org/2001/XMLSchema}nonNegativeInteger" /> + * </extension> + * </complexContent> + * </complexType> + * </pre> + * + * + */ +@XmlAccessorType(XmlAccessType.FIELD) +@XmlType(name = "ProxyRestrictionType", propOrder = { + "audience" +}) +public class ProxyRestrictionType + extends ConditionAbstractType +{ + + @XmlElement(name = "Audience") + @XmlSchemaType(name = "anyURI") + protected List<String> audience; + @XmlAttribute(name = "Count") + @XmlSchemaType(name = "nonNegativeInteger") + protected BigInteger count; + + /** + * Gets the value of the audience property. + * + * <p> + * This accessor method returns a reference to the live list, + * not a snapshot. Therefore any modification you make to the + * returned list will be present inside the JAXB object. + * This is why there is not a <CODE>set</CODE> method for the audience property. + * + * <p> + * For example, to add a new item, do as follows: + * <pre> + * getAudience().add(newItem); + * </pre> + * + * + * <p> + * Objects of the following type(s) are allowed in the list + * {@link String } + * + * + */ + public List<String> getAudience() { + if (audience == null) { + audience = new ArrayList<String>(); + } + return this.audience; + } + + /** + * Ruft den Wert der count-Eigenschaft ab. + * + * @return + * possible object is + * {@link BigInteger } + * + */ + public BigInteger getCount() { + return count; + } + + /** + * Legt den Wert der count-Eigenschaft fest. + * + * @param value + * allowed object is + * {@link BigInteger } + * + */ + public void setCount(BigInteger value) { + this.count = value; + } + +} diff --git a/src/main/java/at/gv/util/xsd/saml/v2_0/assertion/StatementAbstractType.java b/src/main/java/at/gv/util/xsd/saml/v2_0/assertion/StatementAbstractType.java new file mode 100644 index 0000000..44881f9 --- /dev/null +++ b/src/main/java/at/gv/util/xsd/saml/v2_0/assertion/StatementAbstractType.java @@ -0,0 +1,36 @@ + +package at.gv.util.xsd.saml.v2_0.assertion; + +import javax.xml.bind.annotation.XmlAccessType; +import javax.xml.bind.annotation.XmlAccessorType; +import javax.xml.bind.annotation.XmlSeeAlso; +import javax.xml.bind.annotation.XmlType; + + +/** + * <p>Java-Klasse für StatementAbstractType complex type. + * + * <p>Das folgende Schemafragment gibt den erwarteten Content an, der in dieser Klasse enthalten ist. + * + * <pre> + * <complexType name="StatementAbstractType"> + * <complexContent> + * <restriction base="{http://www.w3.org/2001/XMLSchema}anyType"> + * </restriction> + * </complexContent> + * </complexType> + * </pre> + * + * + */ +@XmlAccessorType(XmlAccessType.FIELD) +@XmlType(name = "StatementAbstractType") +@XmlSeeAlso({ + AuthnStatementType.class, + AuthzDecisionStatementType.class, + AttributeStatementType.class +}) +public abstract class StatementAbstractType { + + +} diff --git a/src/main/java/at/gv/util/xsd/saml/v2_0/assertion/SubjectConfirmationDataType.java b/src/main/java/at/gv/util/xsd/saml/v2_0/assertion/SubjectConfirmationDataType.java new file mode 100644 index 0000000..cc1cfff --- /dev/null +++ b/src/main/java/at/gv/util/xsd/saml/v2_0/assertion/SubjectConfirmationDataType.java @@ -0,0 +1,248 @@ + +package at.gv.util.xsd.saml.v2_0.assertion; + +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import javax.xml.bind.annotation.XmlAccessType; +import javax.xml.bind.annotation.XmlAccessorType; +import javax.xml.bind.annotation.XmlAnyAttribute; +import javax.xml.bind.annotation.XmlAnyElement; +import javax.xml.bind.annotation.XmlAttribute; +import javax.xml.bind.annotation.XmlMixed; +import javax.xml.bind.annotation.XmlSchemaType; +import javax.xml.bind.annotation.XmlSeeAlso; +import javax.xml.bind.annotation.XmlType; +import javax.xml.bind.annotation.adapters.CollapsedStringAdapter; +import javax.xml.bind.annotation.adapters.XmlJavaTypeAdapter; +import javax.xml.datatype.XMLGregorianCalendar; +import javax.xml.namespace.QName; +import org.w3c.dom.Element; + + +/** + * <p>Java-Klasse für SubjectConfirmationDataType complex type. + * + * <p>Das folgende Schemafragment gibt den erwarteten Content an, der in dieser Klasse enthalten ist. + * + * <pre> + * <complexType name="SubjectConfirmationDataType"> + * <complexContent> + * <restriction base="{http://www.w3.org/2001/XMLSchema}anyType"> + * <sequence> + * <any processContents='lax' maxOccurs="unbounded" minOccurs="0"/> + * </sequence> + * <attribute name="NotBefore" type="{http://www.w3.org/2001/XMLSchema}dateTime" /> + * <attribute name="NotOnOrAfter" type="{http://www.w3.org/2001/XMLSchema}dateTime" /> + * <attribute name="Recipient" type="{http://www.w3.org/2001/XMLSchema}anyURI" /> + * <attribute name="InResponseTo" type="{http://www.w3.org/2001/XMLSchema}NCName" /> + * <attribute name="Address" type="{http://www.w3.org/2001/XMLSchema}string" /> + * <anyAttribute processContents='lax' namespace='##other'/> + * </restriction> + * </complexContent> + * </complexType> + * </pre> + * + * + */ +@XmlAccessorType(XmlAccessType.FIELD) +@XmlType(name = "SubjectConfirmationDataType", propOrder = { + "content" +}) +@XmlSeeAlso({ + KeyInfoConfirmationDataType.class +}) +public class SubjectConfirmationDataType { + + @XmlMixed + @XmlAnyElement(lax = true) + protected List<Object> content; + @XmlAttribute(name = "NotBefore") + @XmlSchemaType(name = "dateTime") + protected XMLGregorianCalendar notBefore; + @XmlAttribute(name = "NotOnOrAfter") + @XmlSchemaType(name = "dateTime") + protected XMLGregorianCalendar notOnOrAfter; + @XmlAttribute(name = "Recipient") + @XmlSchemaType(name = "anyURI") + protected String recipient; + @XmlAttribute(name = "InResponseTo") + @XmlJavaTypeAdapter(CollapsedStringAdapter.class) + @XmlSchemaType(name = "NCName") + protected String inResponseTo; + @XmlAttribute(name = "Address") + protected String address; + @XmlAnyAttribute + private Map<QName, String> otherAttributes = new HashMap<QName, String>(); + + /** + * Gets the value of the content property. + * + * <p> + * This accessor method returns a reference to the live list, + * not a snapshot. Therefore any modification you make to the + * returned list will be present inside the JAXB object. + * This is why there is not a <CODE>set</CODE> method for the content property. + * + * <p> + * For example, to add a new item, do as follows: + * <pre> + * getContent().add(newItem); + * </pre> + * + * + * <p> + * Objects of the following type(s) are allowed in the list + * {@link String } + * {@link Element } + * {@link Object } + * + * + */ + public List<Object> getContent() { + if (content == null) { + content = new ArrayList<Object>(); + } + return this.content; + } + + /** + * Ruft den Wert der notBefore-Eigenschaft ab. + * + * @return + * possible object is + * {@link XMLGregorianCalendar } + * + */ + public XMLGregorianCalendar getNotBefore() { + return notBefore; + } + + /** + * Legt den Wert der notBefore-Eigenschaft fest. + * + * @param value + * allowed object is + * {@link XMLGregorianCalendar } + * + */ + public void setNotBefore(XMLGregorianCalendar value) { + this.notBefore = value; + } + + /** + * Ruft den Wert der notOnOrAfter-Eigenschaft ab. + * + * @return + * possible object is + * {@link XMLGregorianCalendar } + * + */ + public XMLGregorianCalendar getNotOnOrAfter() { + return notOnOrAfter; + } + + /** + * Legt den Wert der notOnOrAfter-Eigenschaft fest. + * + * @param value + * allowed object is + * {@link XMLGregorianCalendar } + * + */ + public void setNotOnOrAfter(XMLGregorianCalendar value) { + this.notOnOrAfter = value; + } + + /** + * Ruft den Wert der recipient-Eigenschaft ab. + * + * @return + * possible object is + * {@link String } + * + */ + public String getRecipient() { + return recipient; + } + + /** + * Legt den Wert der recipient-Eigenschaft fest. + * + * @param value + * allowed object is + * {@link String } + * + */ + public void setRecipient(String value) { + this.recipient = value; + } + + /** + * Ruft den Wert der inResponseTo-Eigenschaft ab. + * + * @return + * possible object is + * {@link String } + * + */ + public String getInResponseTo() { + return inResponseTo; + } + + /** + * Legt den Wert der inResponseTo-Eigenschaft fest. + * + * @param value + * allowed object is + * {@link String } + * + */ + public void setInResponseTo(String value) { + this.inResponseTo = value; + } + + /** + * Ruft den Wert der address-Eigenschaft ab. + * + * @return + * possible object is + * {@link String } + * + */ + public String getAddress() { + return address; + } + + /** + * Legt den Wert der address-Eigenschaft fest. + * + * @param value + * allowed object is + * {@link String } + * + */ + public void setAddress(String value) { + this.address = value; + } + + /** + * Gets a map that contains attributes that aren't bound to any typed property on this class. + * + * <p> + * the map is keyed by the name of the attribute and + * the value is the string value of the attribute. + * + * the map returned by this method is live, and you can add new attribute + * by updating the map directly. Because of this design, there's no setter. + * + * + * @return + * always non-null + */ + public Map<QName, String> getOtherAttributes() { + return otherAttributes; + } + +} diff --git a/src/main/java/at/gv/util/xsd/saml/v2_0/assertion/SubjectConfirmationType.java b/src/main/java/at/gv/util/xsd/saml/v2_0/assertion/SubjectConfirmationType.java new file mode 100644 index 0000000..3e39c12 --- /dev/null +++ b/src/main/java/at/gv/util/xsd/saml/v2_0/assertion/SubjectConfirmationType.java @@ -0,0 +1,178 @@ + +package at.gv.util.xsd.saml.v2_0.assertion; + +import javax.xml.bind.annotation.XmlAccessType; +import javax.xml.bind.annotation.XmlAccessorType; +import javax.xml.bind.annotation.XmlAttribute; +import javax.xml.bind.annotation.XmlElement; +import javax.xml.bind.annotation.XmlSchemaType; +import javax.xml.bind.annotation.XmlType; + + +/** + * <p>Java-Klasse für SubjectConfirmationType complex type. + * + * <p>Das folgende Schemafragment gibt den erwarteten Content an, der in dieser Klasse enthalten ist. + * + * <pre> + * <complexType name="SubjectConfirmationType"> + * <complexContent> + * <restriction base="{http://www.w3.org/2001/XMLSchema}anyType"> + * <sequence> + * <choice minOccurs="0"> + * <element ref="{urn:oasis:names:tc:SAML:2.0:assertion}BaseID"/> + * <element ref="{urn:oasis:names:tc:SAML:2.0:assertion}NameID"/> + * <element ref="{urn:oasis:names:tc:SAML:2.0:assertion}EncryptedID"/> + * </choice> + * <element ref="{urn:oasis:names:tc:SAML:2.0:assertion}SubjectConfirmationData" minOccurs="0"/> + * </sequence> + * <attribute name="Method" use="required" type="{http://www.w3.org/2001/XMLSchema}anyURI" /> + * </restriction> + * </complexContent> + * </complexType> + * </pre> + * + * + */ +@XmlAccessorType(XmlAccessType.FIELD) +@XmlType(name = "SubjectConfirmationType", propOrder = { + "baseID", + "nameID", + "encryptedID", + "subjectConfirmationData" +}) +public class SubjectConfirmationType { + + @XmlElement(name = "BaseID") + protected BaseIDAbstractType baseID; + @XmlElement(name = "NameID") + protected NameIDType nameID; + @XmlElement(name = "EncryptedID") + protected EncryptedElementType encryptedID; + @XmlElement(name = "SubjectConfirmationData") + protected SubjectConfirmationDataType subjectConfirmationData; + @XmlAttribute(name = "Method", required = true) + @XmlSchemaType(name = "anyURI") + protected String method; + + /** + * Ruft den Wert der baseID-Eigenschaft ab. + * + * @return + * possible object is + * {@link BaseIDAbstractType } + * + */ + public BaseIDAbstractType getBaseID() { + return baseID; + } + + /** + * Legt den Wert der baseID-Eigenschaft fest. + * + * @param value + * allowed object is + * {@link BaseIDAbstractType } + * + */ + public void setBaseID(BaseIDAbstractType value) { + this.baseID = value; + } + + /** + * Ruft den Wert der nameID-Eigenschaft ab. + * + * @return + * possible object is + * {@link NameIDType } + * + */ + public NameIDType getNameID() { + return nameID; + } + + /** + * Legt den Wert der nameID-Eigenschaft fest. + * + * @param value + * allowed object is + * {@link NameIDType } + * + */ + public void setNameID(NameIDType value) { + this.nameID = value; + } + + /** + * Ruft den Wert der encryptedID-Eigenschaft ab. + * + * @return + * possible object is + * {@link EncryptedElementType } + * + */ + public EncryptedElementType getEncryptedID() { + return encryptedID; + } + + /** + * Legt den Wert der encryptedID-Eigenschaft fest. + * + * @param value + * allowed object is + * {@link EncryptedElementType } + * + */ + public void setEncryptedID(EncryptedElementType value) { + this.encryptedID = value; + } + + /** + * Ruft den Wert der subjectConfirmationData-Eigenschaft ab. + * + * @return + * possible object is + * {@link SubjectConfirmationDataType } + * + */ + public SubjectConfirmationDataType getSubjectConfirmationData() { + return subjectConfirmationData; + } + + /** + * Legt den Wert der subjectConfirmationData-Eigenschaft fest. + * + * @param value + * allowed object is + * {@link SubjectConfirmationDataType } + * + */ + public void setSubjectConfirmationData(SubjectConfirmationDataType value) { + this.subjectConfirmationData = value; + } + + /** + * Ruft den Wert der method-Eigenschaft ab. + * + * @return + * possible object is + * {@link String } + * + */ + public String getMethod() { + return method; + } + + /** + * Legt den Wert der method-Eigenschaft fest. + * + * @param value + * allowed object is + * {@link String } + * + */ + public void setMethod(String value) { + this.method = value; + } + +} diff --git a/src/main/java/at/gv/util/xsd/saml/v2_0/assertion/SubjectLocalityType.java b/src/main/java/at/gv/util/xsd/saml/v2_0/assertion/SubjectLocalityType.java new file mode 100644 index 0000000..7a9f862 --- /dev/null +++ b/src/main/java/at/gv/util/xsd/saml/v2_0/assertion/SubjectLocalityType.java @@ -0,0 +1,85 @@ + +package at.gv.util.xsd.saml.v2_0.assertion; + +import javax.xml.bind.annotation.XmlAccessType; +import javax.xml.bind.annotation.XmlAccessorType; +import javax.xml.bind.annotation.XmlAttribute; +import javax.xml.bind.annotation.XmlType; + + +/** + * <p>Java-Klasse für SubjectLocalityType complex type. + * + * <p>Das folgende Schemafragment gibt den erwarteten Content an, der in dieser Klasse enthalten ist. + * + * <pre> + * <complexType name="SubjectLocalityType"> + * <complexContent> + * <restriction base="{http://www.w3.org/2001/XMLSchema}anyType"> + * <attribute name="Address" type="{http://www.w3.org/2001/XMLSchema}string" /> + * <attribute name="DNSName" type="{http://www.w3.org/2001/XMLSchema}string" /> + * </restriction> + * </complexContent> + * </complexType> + * </pre> + * + * + */ +@XmlAccessorType(XmlAccessType.FIELD) +@XmlType(name = "SubjectLocalityType") +public class SubjectLocalityType { + + @XmlAttribute(name = "Address") + protected String address; + @XmlAttribute(name = "DNSName") + protected String dnsName; + + /** + * Ruft den Wert der address-Eigenschaft ab. + * + * @return + * possible object is + * {@link String } + * + */ + public String getAddress() { + return address; + } + + /** + * Legt den Wert der address-Eigenschaft fest. + * + * @param value + * allowed object is + * {@link String } + * + */ + public void setAddress(String value) { + this.address = value; + } + + /** + * Ruft den Wert der dnsName-Eigenschaft ab. + * + * @return + * possible object is + * {@link String } + * + */ + public String getDNSName() { + return dnsName; + } + + /** + * Legt den Wert der dnsName-Eigenschaft fest. + * + * @param value + * allowed object is + * {@link String } + * + */ + public void setDNSName(String value) { + this.dnsName = value; + } + +} diff --git a/src/main/java/at/gv/util/xsd/saml/v2_0/assertion/SubjectType.java b/src/main/java/at/gv/util/xsd/saml/v2_0/assertion/SubjectType.java new file mode 100644 index 0000000..95e5c9b --- /dev/null +++ b/src/main/java/at/gv/util/xsd/saml/v2_0/assertion/SubjectType.java @@ -0,0 +1,97 @@ + +package at.gv.util.xsd.saml.v2_0.assertion; + +import java.util.ArrayList; +import java.util.List; +import javax.xml.bind.JAXBElement; +import javax.xml.bind.annotation.XmlAccessType; +import javax.xml.bind.annotation.XmlAccessorType; +import javax.xml.bind.annotation.XmlElementRef; +import javax.xml.bind.annotation.XmlElementRefs; +import javax.xml.bind.annotation.XmlType; + + +/** + * <p>Java-Klasse für SubjectType complex type. + * + * <p>Das folgende Schemafragment gibt den erwarteten Content an, der in dieser Klasse enthalten ist. + * + * <pre> + * <complexType name="SubjectType"> + * <complexContent> + * <restriction base="{http://www.w3.org/2001/XMLSchema}anyType"> + * <choice> + * <sequence> + * <choice> + * <element ref="{urn:oasis:names:tc:SAML:2.0:assertion}BaseID"/> + * <element ref="{urn:oasis:names:tc:SAML:2.0:assertion}NameID"/> + * <element ref="{urn:oasis:names:tc:SAML:2.0:assertion}EncryptedID"/> + * </choice> + * <element ref="{urn:oasis:names:tc:SAML:2.0:assertion}SubjectConfirmation" maxOccurs="unbounded" minOccurs="0"/> + * </sequence> + * <element ref="{urn:oasis:names:tc:SAML:2.0:assertion}SubjectConfirmation" maxOccurs="unbounded"/> + * </choice> + * </restriction> + * </complexContent> + * </complexType> + * </pre> + * + * + */ +@XmlAccessorType(XmlAccessType.FIELD) +@XmlType(name = "SubjectType", propOrder = { + "content" +}) +public class SubjectType { + + @XmlElementRefs({ + @XmlElementRef(name = "EncryptedID", namespace = "urn:oasis:names:tc:SAML:2.0:assertion", type = JAXBElement.class, required = false), + @XmlElementRef(name = "NameID", namespace = "urn:oasis:names:tc:SAML:2.0:assertion", type = JAXBElement.class, required = false), + @XmlElementRef(name = "SubjectConfirmation", namespace = "urn:oasis:names:tc:SAML:2.0:assertion", type = JAXBElement.class, required = false), + @XmlElementRef(name = "BaseID", namespace = "urn:oasis:names:tc:SAML:2.0:assertion", type = JAXBElement.class, required = false) + }) + protected List<JAXBElement<?>> content; + + /** + * Ruft das restliche Contentmodell ab. + * + * <p> + * Sie rufen diese "catch-all"-Eigenschaft aus folgendem Grund ab: + * Der Feldname "SubjectConfirmation" wird von zwei verschiedenen Teilen eines Schemas verwendet. Siehe: + * Zeile 0 von https://docs.oasis-open.org/security/saml/v2.0/saml-schema-assertion-2.0.xsd + * Zeile 0 von https://docs.oasis-open.org/security/saml/v2.0/saml-schema-assertion-2.0.xsd + * <p> + * Um diese Eigenschaft zu entfernen, wenden Sie eine Eigenschaftenanpassung für eine + * der beiden folgenden Deklarationen an, um deren Namen zu ändern: + * Gets the value of the content property. + * + * <p> + * This accessor method returns a reference to the live list, + * not a snapshot. Therefore any modification you make to the + * returned list will be present inside the JAXB object. + * This is why there is not a <CODE>set</CODE> method for the content property. + * + * <p> + * For example, to add a new item, do as follows: + * <pre> + * getContent().add(newItem); + * </pre> + * + * + * <p> + * Objects of the following type(s) are allowed in the list + * {@link JAXBElement }{@code <}{@link EncryptedElementType }{@code >} + * {@link JAXBElement }{@code <}{@link NameIDType }{@code >} + * {@link JAXBElement }{@code <}{@link SubjectConfirmationType }{@code >} + * {@link JAXBElement }{@code <}{@link BaseIDAbstractType }{@code >} + * + * + */ + public List<JAXBElement<?>> getContent() { + if (content == null) { + content = new ArrayList<JAXBElement<?>>(); + } + return this.content; + } + +} diff --git a/src/main/java/at/gv/util/xsd/saml/v2_0/assertion/package-info.java b/src/main/java/at/gv/util/xsd/saml/v2_0/assertion/package-info.java new file mode 100644 index 0000000..925633d --- /dev/null +++ b/src/main/java/at/gv/util/xsd/saml/v2_0/assertion/package-info.java @@ -0,0 +1,2 @@ +@javax.xml.bind.annotation.XmlSchema(namespace = "urn:oasis:names:tc:SAML:2.0:assertion", elementFormDefault = javax.xml.bind.annotation.XmlNsForm.QUALIFIED) +package at.gv.util.xsd.saml.v2_0.assertion; |