Commons XMLCommons XML

<xs:simpleType xmlns:xs="http://www.w3.org/2001/XMLSchema" name="double_2Decimals">
           <xs:annotation>
              <xs:documentation>Double with 2 decimal places</xs:documentation>
           </xs:annotation>
           <xs:restriction base="xs:decimal">
              <xs:fractionDigits value="2"/>
           </xs:restriction>
        </xs:simpleType>

<xs:simpleType xmlns:xs="http://www.w3.org/2001/XMLSchema" name="string_2048">
           <xs:annotation>
              <xs:documentation>Free text string of maximum 2048 characters</xs:documentation>
           </xs:annotation>
           <xs:restriction base="xs:string">
              <xs:maxLength value="2048"/>
           </xs:restriction>
        </xs:simpleType>

<xs:simpleType xmlns:xs="http://www.w3.org/2001/XMLSchema" name="string_1024">
           <xs:annotation>
              <xs:documentation>Free text string of maximum 1024 characters</xs:documentation>
           </xs:annotation>
           <xs:restriction base="xs:string">
              <xs:maxLength value="1024"/>
           </xs:restriction>
        </xs:simpleType>

<xs:simpleType xmlns:xs="http://www.w3.org/2001/XMLSchema" name="string_512">
           <xs:annotation>
              <xs:documentation>Free text string of maximum 512 characters</xs:documentation>
           </xs:annotation>
           <xs:restriction base="xs:string">
              <xs:maxLength value="512"/>
           </xs:restriction>
        </xs:simpleType>

<xs:simpleType xmlns:xs="http://www.w3.org/2001/XMLSchema" name="string_400">
           <xs:annotation>
              <xs:documentation>Free text string of maximum 400 characters</xs:documentation>
           </xs:annotation>
           <xs:restriction base="xs:string">
              <xs:maxLength value="400"/>
           </xs:restriction>
        </xs:simpleType>

<xs:simpleType xmlns:xs="http://www.w3.org/2001/XMLSchema" name="string_256">
           <xs:annotation>
              <xs:documentation>Free text string of maximum 256 characters</xs:documentation>
           </xs:annotation>
           <xs:restriction base="xs:string">
              <xs:maxLength value="256"/>
           </xs:restriction>
        </xs:simpleType>

<xs:simpleType xmlns:xs="http://www.w3.org/2001/XMLSchema" name="string_128">
           <xs:annotation>
              <xs:documentation>Free text string of maximum 128 characters</xs:documentation>
           </xs:annotation>
           <xs:restriction base="xs:string">
              <xs:maxLength value="128"/>
           </xs:restriction>
        </xs:simpleType>

<xs:simpleType xmlns:xs="http://www.w3.org/2001/XMLSchema" name="string_20">
           <xs:annotation>
              <xs:documentation>Free text string of maximum 20 characters</xs:documentation>
           </xs:annotation>
           <xs:restriction base="xs:string">
              <xs:maxLength value="20"/>
           </xs:restriction>
        </xs:simpleType>

<xs:simpleType xmlns:xs="http://www.w3.org/2001/XMLSchema" name="string_40">
           <xs:annotation>
              <xs:documentation>Free text string of maximum 40 characters</xs:documentation>
           </xs:annotation>
           <xs:restriction base="xs:string">
              <xs:maxLength value="40"/>
           </xs:restriction>
        </xs:simpleType>

<xs:simpleType xmlns:xs="http://www.w3.org/2001/XMLSchema" name="string_64">
           <xs:annotation>
              <xs:documentation>Free text string of maximum 64 characters</xs:documentation>
           </xs:annotation>
           <xs:restriction base="xs:string">
              <xs:maxLength value="64"/>
           </xs:restriction>
        </xs:simpleType>

<xs:simpleType xmlns:xs="http://www.w3.org/2001/XMLSchema" name="string_9">
           <xs:annotation>
              <xs:documentation>Free text string of maximum 9 characters</xs:documentation>
           </xs:annotation>
           <xs:restriction base="xs:string">
              <xs:maxLength value="9"/>
           </xs:restriction>
        </xs:simpleType>

<xs:simpleType xmlns:xs="http://www.w3.org/2001/XMLSchema" name="percent">
           <xs:annotation>
              <xs:documentation>Percentage represented as a decimal between 0 and 1</xs:documentation>
           </xs:annotation>
           <xs:restriction base="xs:float">
              <xs:maxInclusive value="1"/>
              <xs:minInclusive value="0"/>
           </xs:restriction>
        </xs:simpleType>

<xs:simpleType xmlns:xs="http://www.w3.org/2001/XMLSchema" name="language">
           <xs:annotation>
              <xs:documentation>Language code, which should be represented in /dk/atira/pure/core/languages classification scheme</xs:documentation>
           </xs:annotation>
           <xs:restriction base="xs:string">
              <xs:pattern value="([a-z]{2}_[A-Z]{2})|([a-z]{2}|mul|und|mis)"/>
           </xs:restriction>
        </xs:simpleType>

<xs:simpleType xmlns:xs="http://www.w3.org/2001/XMLSchema" name="country">
           <xs:annotation>
              <xs:documentation>2 letter country code</xs:documentation>
           </xs:annotation>
           <xs:restriction base="xs:string">
              <xs:pattern value="[A-Z]{2}"/>
           </xs:restriction>
        </xs:simpleType>

<xs:complexType xmlns:xs="http://www.w3.org/2001/XMLSchema" name="localized_string">
           <xs:annotation>
              <xs:documentation>A list of text elements, can specify different values for each submission language setup in Pure</xs:documentation>
           </xs:annotation>
           <xs:sequence>
              <xs:element name="text" type="cmns:localized_text" maxOccurs="unbounded"/>
           </xs:sequence>
        </xs:complexType>

<xs:complexType xmlns:xs="http://www.w3.org/2001/XMLSchema" name="localized_text">
           <xs:annotation>
              <xs:documentation>A free text string with optional language specification if using multiple submission languages</xs:documentation>
           </xs:annotation>
           <xs:simpleContent>
              <xs:extension base="xs:string">
                 <xs:attribute type="cmns:language" name="lang">
                    <xs:annotation>
                       <xs:documentation>An ISO 639-1 code</xs:documentation>
                    </xs:annotation>
                 </xs:attribute>
                 <xs:attribute type="cmns:country" name="country">
                    <xs:annotation>
                       <xs:documentation>An ISO 3166-1 code</xs:documentation>
                    </xs:annotation>
                 </xs:attribute>
              </xs:extension>
           </xs:simpleContent>
        </xs:complexType>

<xs:complexType xmlns:xs="http://www.w3.org/2001/XMLSchema" name="localized_string_256">
           <xs:annotation>
              <xs:documentation>A list of text elements of maximum 256 characters, can specify different values for each submission language setup in Pure</xs:documentation>
           </xs:annotation>
           <xs:sequence>
              <xs:element name="text" type="cmns:localized_text_256" maxOccurs="unbounded"/>
           </xs:sequence>
        </xs:complexType>

<xs:complexType xmlns:xs="http://www.w3.org/2001/XMLSchema" name="localized_text_256">
           <xs:annotation>
              <xs:documentation>A free text string of maximum 256 characters with optional language specification if using multiple submission languages</xs:documentation>
           </xs:annotation>
           <xs:simpleContent>
              <xs:extension base="cmns:string_256">
                 <xs:attribute type="cmns:language" name="lang">
                    <xs:annotation>
                       <xs:documentation>An ISO 639-1 code</xs:documentation>
                    </xs:annotation>
                 </xs:attribute>
                 <xs:attribute type="cmns:country" name="country">
                    <xs:annotation>
                       <xs:documentation>An ISO 3166-1 code</xs:documentation>
                    </xs:annotation>
                 </xs:attribute>
              </xs:extension>
           </xs:simpleContent>
        </xs:complexType>

<xs:complexType xmlns:xs="http://www.w3.org/2001/XMLSchema" name="localized_text_lang">
           <xs:annotation>
              <xs:documentation>A free text string with optional language specification if using multiple submission languages</xs:documentation>
           </xs:annotation>
           <xs:simpleContent>
              <xs:extension base="xs:string">
                 <xs:attribute type="cmns:language" name="lang" use="optional">
                    <xs:annotation>
                       <xs:documentation>An ISO 639-1 code and this locale should be a submission locale in the Pure installation</xs:documentation>
                    </xs:annotation>
                 </xs:attribute>
              </xs:extension>
           </xs:simpleContent>
        </xs:complexType>

<xs:complexType xmlns:xs="http://www.w3.org/2001/XMLSchema" name="localized_text_256_lang">
           <xs:annotation>
              <xs:documentation>A free text string of maximum 256 characters with language specification</xs:documentation>
           </xs:annotation>
           <xs:simpleContent>
              <xs:extension base="cmns:string_256">
                 <xs:attribute type="cmns:language" name="lang" use="required">
                    <xs:annotation>
                       <xs:documentation>An ISO 639-1 code</xs:documentation>
                    </xs:annotation>
                 </xs:attribute>
              </xs:extension>
           </xs:simpleContent>
        </xs:complexType>

<xs:complexType xmlns:xs="http://www.w3.org/2001/XMLSchema" name="localized_text_1024_lang">
           <xs:annotation>
              <xs:documentation>A free text string of maximum 1024 characters with language specification</xs:documentation>
           </xs:annotation>
           <xs:simpleContent>
              <xs:extension base="cmns:string_1024">
                 <xs:attribute type="cmns:language" name="lang" use="required">
                    <xs:annotation>
                       <xs:documentation>An ISO 639-1 code</xs:documentation>
                    </xs:annotation>
                 </xs:attribute>
              </xs:extension>
           </xs:simpleContent>
        </xs:complexType>

<xs:complexType xmlns:xs="http://www.w3.org/2001/XMLSchema" name="localized_string_1024">
           <xs:annotation>
              <xs:documentation>A list of text elements of maximum 1024 characters, can specify different values for each submission language setup in Pure</xs:documentation>
           </xs:annotation>
           <xs:sequence>
              <xs:element name="text" type="cmns:localized_text_1024" maxOccurs="unbounded"/>
           </xs:sequence>
        </xs:complexType>

<xs:complexType xmlns:xs="http://www.w3.org/2001/XMLSchema" name="localized_text_1024">
           <xs:annotation>
              <xs:documentation>A free text string of maximum 1024 characters with optional language specification if using multiple submission languages</xs:documentation>
           </xs:annotation>
           <xs:simpleContent>
              <xs:extension base="cmns:string_1024">
                 <xs:attribute type="cmns:language" name="lang">
                    <xs:annotation>
                       <xs:documentation>An ISO 639-1 code</xs:documentation>
                    </xs:annotation>
                 </xs:attribute>
                 <xs:attribute type="cmns:country" name="country">
                    <xs:annotation>
                       <xs:documentation>An ISO 3166-1 code</xs:documentation>
                    </xs:annotation>
                 </xs:attribute>
              </xs:extension>
           </xs:simpleContent>
        </xs:complexType>

<xs:complexType xmlns:xs="http://www.w3.org/2001/XMLSchema"
                        name="localized_string_1024_required_lang">
           <xs:annotation>
              <xs:documentation>A list of text elements of maximum 1024 characters, with language required</xs:documentation>
           </xs:annotation>
           <xs:sequence>
              <xs:element name="text"
                          type="cmns:localized_text_1024_required_lang"
                          maxOccurs="unbounded"/>
           </xs:sequence>
        </xs:complexType>

<xs:complexType xmlns:xs="http://www.w3.org/2001/XMLSchema"
                        name="localized_text_1024_required_lang">
           <xs:annotation>
              <xs:documentation>A free text string of maximum 1024 characters with language specification required</xs:documentation>
           </xs:annotation>
           <xs:simpleContent>
              <xs:extension base="cmns:string_1024">
                 <xs:attribute type="cmns:language" name="lang" use="required">
                    <xs:annotation>
                       <xs:documentation>An ISO 639-1 code</xs:documentation>
                    </xs:annotation>
                 </xs:attribute>
                 <xs:attribute type="cmns:country" name="country">
                    <xs:annotation>
                       <xs:documentation>An ISO 3166-1 code</xs:documentation>
                    </xs:annotation>
                 </xs:attribute>
              </xs:extension>
           </xs:simpleContent>
        </xs:complexType>

<xs:complexType xmlns:xs="http://www.w3.org/2001/XMLSchema" name="descriptions">
           <xs:annotation>
              <xs:documentation>A collection of description elements. These should each map to a type defined the relevant classification scheme for this content type and can be repeated with different language tags to cater for multiple submission languages</xs:documentation>
           </xs:annotation>
           <xs:sequence>
              <xs:element name="description"
                          type="cmns:classified_localized_string"
                          maxOccurs="unbounded"/>
           </xs:sequence>
        </xs:complexType>

<xs:complexType xmlns:xs="http://www.w3.org/2001/XMLSchema"
                        name="classified_localized_string">
           <xs:annotation>
              <xs:documentation>A description for a particular type, as defined in the description classification scheme for this content type. The language can be specified if using multiple submission languages</xs:documentation>
           </xs:annotation>
           <xs:complexContent>
              <xs:extension base="cmns:localized_string">
                 <xs:attribute name="type" type="cmns:classification" use="required">
                    <xs:annotation>
                       <xs:documentation>token from the classification e.g. /dk/atira/pure/upmproject/description. Note a different classification is used for each content type</xs:documentation>
                    </xs:annotation>
                 </xs:attribute>
              </xs:extension>
           </xs:complexContent>
        </xs:complexType>

<xs:simpleType xmlns:xs="http://www.w3.org/2001/XMLSchema" name="visibility">
           <xs:annotation>
              <xs:documentation>Where the record can be seen across both the Pure backend, web service and portal</xs:documentation>
           </xs:annotation>
           <xs:restriction base="xs:string">
              <xs:enumeration value="Public">
                 <xs:annotation>
                    <xs:documentation>Publicly available</xs:documentation>
                 </xs:annotation>
              </xs:enumeration>
              <xs:enumeration value="Campus">
                 <xs:annotation>
                    <xs:documentation>Only visible to users visiting from within defined IP range</xs:documentation>
                 </xs:annotation>
              </xs:enumeration>
              <xs:enumeration value="Restricted">
                 <xs:annotation>
                    <xs:documentation>Only visible when logged in to Pure.</xs:documentation>
                 </xs:annotation>
              </xs:enumeration>
              <xs:enumeration value="Confidential">
                 <xs:annotation>
                    <xs:documentation>Only visible when logged into Pure and only for contributors and users with editorial rights to the content</xs:documentation>
                 </xs:annotation>
              </xs:enumeration>
           </xs:restriction>
        </xs:simpleType>

<xs:simpleType xmlns:xs="http://www.w3.org/2001/XMLSchema"
                       name="visibilityWithOutConfidential">
           <xs:annotation>
              <xs:documentation>Where the record can be seen across both the Pure backend, web service and portal</xs:documentation>
           </xs:annotation>
           <xs:restriction base="xs:string">
              <xs:enumeration value="Public">
                 <xs:annotation>
                    <xs:documentation>Publicly available</xs:documentation>
                 </xs:annotation>
              </xs:enumeration>
              <xs:enumeration value="Campus">
                 <xs:annotation>
                    <xs:documentation>Only visible to users visiting from within defined IP range</xs:documentation>
                 </xs:annotation>
              </xs:enumeration>
              <xs:enumeration value="Restricted">
                 <xs:annotation>
                    <xs:documentation>Only visible when logged in to Pure.</xs:documentation>
                 </xs:annotation>
              </xs:enumeration>
           </xs:restriction>
        </xs:simpleType>

<xs:simpleType xmlns:xs="http://www.w3.org/2001/XMLSchema" name="classification">
           <xs:annotation>
              <xs:documentation>The token of a classification element defined within a scheme in Pure. Note that the value needs to exist on the expected classification scheme. See the referring element for which classification scheme to use</xs:documentation>
           </xs:annotation>
           <xs:restriction base="cmns:string_1024">
              <xs:pattern value="[^\p{C}\p{Z}]+"/>
           </xs:restriction>
        </xs:simpleType>

<xs:complexType xmlns:xs="http://www.w3.org/2001/XMLSchema" name="keywords">
           <xs:annotation>
              <xs:documentation>A collection of keywords related to the content. These can be free text and/or tied to classification schemes and are managed via the Administrator -&gt; Keywords. There are two different ways keywords can be represented. The cmns:keyword is recommended as a simpler, more intuitive format</xs:documentation>
           </xs:annotation>
           <xs:choice>
              <xs:sequence maxOccurs="unbounded" minOccurs="1">
                 <xs:element name="logicalGroup" type="cmns:logicalGroup"/>
              </xs:sequence>
              <xs:sequence>
                 <xs:element name="keyword" type="cmns:keyword" maxOccurs="unbounded"/>
              </xs:sequence>
           </xs:choice>
        </xs:complexType>

<xs:complexType xmlns:xs="http://www.w3.org/2001/XMLSchema" name="logicalGroup">
           <xs:sequence>
              <xs:element name="structuredKeywords"
                          type="cmns:structuredKeywords"
                          minOccurs="1"
                          maxOccurs="unbounded">
                 <xs:annotation>
                    <xs:documentation>List of keywordGroups if keywords should be placed in different groups</xs:documentation>
                 </xs:annotation>
              </xs:element>
           </xs:sequence>
           <xs:attribute name="logicalName" type="xs:string" use="optional">
              <xs:annotation>
                 <xs:documentation>The logical name for the keyword group, if not a default group will be used</xs:documentation>
              </xs:annotation>
           </xs:attribute>
        </xs:complexType>

<xs:complexType xmlns:xs="http://www.w3.org/2001/XMLSchema" name="freeKeywords">
           <xs:sequence>
              <xs:element name="freeKeyword"
                          type="cmns:localized_string"
                          minOccurs="1"
                          maxOccurs="unbounded">
                 <xs:annotation>
                    <xs:documentation>List of free keywords</xs:documentation>
                 </xs:annotation>
              </xs:element>
           </xs:sequence>
        </xs:complexType>

<xs:complexType xmlns:xs="http://www.w3.org/2001/XMLSchema" name="structuredKeywords">
           <xs:sequence minOccurs="1" maxOccurs="unbounded">
              <xs:element name="structuredKeyword" type="cmns:structuredKeyword">
                 <xs:annotation>
                    <xs:documentation>List of structured keywords</xs:documentation>
                 </xs:annotation>
              </xs:element>
           </xs:sequence>
        </xs:complexType>

<xs:complexType xmlns:xs="http://www.w3.org/2001/XMLSchema" name="structuredKeyword">
           <xs:sequence>
              <xs:element name="freeKeywords"
                          type="cmns:freeKeywords"
                          minOccurs="0"
                          maxOccurs="unbounded">
                 <xs:annotation>
                    <xs:documentation>List of free keywords that are related to the structured keyword</xs:documentation>
                 </xs:annotation>
              </xs:element>
           </xs:sequence>
           <xs:attribute name="classification" type="cmns:classification" use="optional">
              <xs:annotation>
                 <xs:documentation>token for the structured keyword, if not set the keywords below will be read as free keywords not related to any structured keyword</xs:documentation>
              </xs:annotation>
           </xs:attribute>
        </xs:complexType>

<xs:complexType xmlns:xs="http://www.w3.org/2001/XMLSchema" name="keyword">
           <xs:annotation>
              <xs:documentation>Keyword, either a free text keyword, a structured keyword or a structured keyword with a free text keyword</xs:documentation>
           </xs:annotation>
           <xs:simpleContent>
              <xs:extension base="cmns:localized_text_lang">
                 <xs:attribute name="logicalName" default="keywordContainers" use="optional">
                    <xs:annotation>
                       <xs:documentation>Logical name of the keyword group where the keyword should be placed. The default value referers to the default Keywords group</xs:documentation>
                    </xs:annotation>
                 </xs:attribute>
                 <xs:attribute name="key" use="optional">
                    <xs:annotation>
                       <xs:documentation>
                                    The key of the keyword classification which represents a structured keyword. You must only provide the last part of the uri (key) of the classification you want to use.
                                    The allowed keys depends on what classifications are in the keyword group with the provided logicalName
                                    For example if the specified logical name uses the classification scheme /dk/atira/pure/subjectarea/asjc
                                    then the key would be 1000 if you want to set 'General' as the structured keyword and 1200/1213 if you want 'Visual Arts and Performing Arts' under 'Arts and
                                    Humanities(all)'
                                    If the specified logical name use a classification scheme, then the key is required.
                                    To add a free text keyword to a structured keyword, you must specify logicalName, key and the text of the keyword.
                                    Note the keyword configurations determines whether this is possible.
                                </xs:documentation>
                    </xs:annotation>
                 </xs:attribute>
              </xs:extension>
           </xs:simpleContent>
        </xs:complexType>

<xs:complexType xmlns:xs="http://www.w3.org/2001/XMLSchema" name="contentReferences">
           <xs:annotation>
              <xs:documentation>Content references can create relationships between content types</xs:documentation>
           </xs:annotation>
           <xs:sequence>
              <xs:element name="contentReference"
                          type="cmns:contentReference"
                          maxOccurs="unbounded"
                          minOccurs="1"/>
           </xs:sequence>
        </xs:complexType>

<xs:complexType xmlns:xs="http://www.w3.org/2001/XMLSchema" name="contentReference">
           <xs:sequence>
              <xs:element name="contentName" type="cmns:string_1024" minOccurs="0">
                 <xs:annotation>
                    <xs:documentation>This field is deprecated, matching by name is not supported. Data entered in this field is not used for matching.</xs:documentation>
                 </xs:annotation>
              </xs:element>
           </xs:sequence>
           <xs:attribute type="cmns:non_explicit_id" name="contentId">
              <xs:annotation>
                 <xs:documentation>The ID of the content</xs:documentation>
              </xs:annotation>
           </xs:attribute>
        </xs:complexType>

<xs:complexType xmlns:xs="http://www.w3.org/2001/XMLSchema" name="externalCollaborators">
           <xs:sequence>
              <xs:element name="collaborator"
                          type="cmns:externalCollaborator"
                          maxOccurs="unbounded"/>
           </xs:sequence>
        </xs:complexType>

<xs:complexType xmlns:xs="http://www.w3.org/2001/XMLSchema" name="externalCollaborator">
           <xs:annotation>
              <xs:documentation>Details of the external collaborating organisation</xs:documentation>
           </xs:annotation>
           <xs:all>
              <xs:element name="externalOrgName" type="cmns:string_1024" minOccurs="0">
                 <xs:annotation>
                    <xs:documentation>Name of an external organisation for this participant</xs:documentation>
                 </xs:annotation>
              </xs:element>
              <xs:element name="externalOrgType" type="cmns:classification" minOccurs="0">
                 <xs:annotation>
                    <xs:documentation>token from the classification scheme /dk/atira/pure/ueoexternalorganisation/ueoexternalorganisationtypes</xs:documentation>
                 </xs:annotation>
              </xs:element>
              <xs:element name="externalOrgId" type="cmns:string_1024" minOccurs="0">
                 <xs:annotation>
                    <xs:documentation>Source id of an external organisation</xs:documentation>
                 </xs:annotation>
              </xs:element>
              <xs:element name="leadCollaborator" type="xs:boolean" minOccurs="0">
                 <xs:annotation>
                    <xs:documentation>Whether the organisation is the lead organistion. Only one organisation should have this value set as true</xs:documentation>
                 </xs:annotation>
              </xs:element>
           </xs:all>
           <xs:attribute name="type" type="cmns:classification" use="optional">
              <xs:annotation>
                 <xs:documentation>token from classification scheme /dk/atira/pure/upm/collaborator</xs:documentation>
              </xs:annotation>
           </xs:attribute>
        </xs:complexType>

<xs:complexType xmlns:xs="http://www.w3.org/2001/XMLSchema"
                        name="externalOrganisationAssociations">
           <xs:sequence>
              <xs:element name="externalOrganisationAssociation"
                          type="cmns:externalOrganisationAssociation"
                          maxOccurs="unbounded"/>
           </xs:sequence>
        </xs:complexType>

<xs:complexType xmlns:xs="http://www.w3.org/2001/XMLSchema"
                        name="externalOrganisationAssociation">
           <xs:annotation>
              <xs:documentation>Details of the external organisation. If the ID is not provided then Pure will attempt to find results matching on name and type</xs:documentation>
           </xs:annotation>
           <xs:sequence>
              <xs:element name="externalOrgName" type="cmns:string_1024" minOccurs="0">
                 <xs:annotation>
                    <xs:documentation>Name of an external organisation for this participant</xs:documentation>
                 </xs:annotation>
              </xs:element>
              <xs:element name="externalOrgType" type="cmns:classification" minOccurs="0">
                 <xs:annotation>
                    <xs:documentation>Token from the classification scheme /dk/atira/pure/ueoexternalorganisation/ueoexternalorganisationtypes</xs:documentation>
                 </xs:annotation>
              </xs:element>
              <xs:element name="externalOrgId" type="cmns:string_1024" minOccurs="0">
                 <xs:annotation>
                    <xs:documentation>Source id of an external organisation</xs:documentation>
                 </xs:annotation>
              </xs:element>
           </xs:sequence>
        </xs:complexType>

<xs:complexType xmlns:xs="http://www.w3.org/2001/XMLSchema" name="externalOrganisations">
           <xs:sequence>
              <xs:element name="externalOrganisation"
                          type="cmns:externalOrganisation"
                          maxOccurs="unbounded"/>
           </xs:sequence>
        </xs:complexType>

<xs:complexType xmlns:xs="http://www.w3.org/2001/XMLSchema" name="externalOrganisation">
           <xs:annotation>
              <xs:documentation>Details of the external organisation. If the ID is not provided then Pure will attempt to find results matching on name, type and country (if provided)</xs:documentation>
           </xs:annotation>
           <xs:all>
              <xs:element name="name" type="cmns:string_1024" minOccurs="0">
                 <xs:annotation>
                    <xs:documentation>The name of the external organisation</xs:documentation>
                 </xs:annotation>
              </xs:element>
              <xs:element name="type" type="cmns:classification" minOccurs="0">
                 <xs:annotation>
                    <xs:documentation>Type of the organisation. Must be from the classification scheme /dk/atira/pure/ueoexternalorganisation/ueoexternalorganisationtypes</xs:documentation>
                 </xs:annotation>
              </xs:element>
              <xs:element name="country" type="cmns:classification" minOccurs="0">
                 <xs:annotation>
                    <xs:documentation>Country of the organisation. Must be from the classification scheme /dk/atira/pure/core/countries</xs:documentation>
                 </xs:annotation>
              </xs:element>
              <xs:element name="externalOrgId" type="cmns:string_1024" minOccurs="0">
                 <xs:annotation>
                    <xs:documentation>Source id of an external organisation</xs:documentation>
                 </xs:annotation>
              </xs:element>
              <xs:element name="externalOrgSource" type="cmns:string_1024" minOccurs="0">
                 <xs:annotation>
                    <xs:documentation>Source of an external organisation</xs:documentation>
                 </xs:annotation>
              </xs:element>
           </xs:all>
        </xs:complexType>

<xs:complexType xmlns:xs="http://www.w3.org/2001/XMLSchema" name="organisation">
           <xs:annotation>
              <xs:documentation>Details of the internal organisation. If the ID is not provided then Pure will attempt to find results matching on name</xs:documentation>
           </xs:annotation>
           <xs:all>
              <xs:element name="name" type="cmns:localized_string" minOccurs="0"/>
              <xs:element name="name_variant"
                          type="cmns:classified_localized_string"
                          minOccurs="0"/>
              <xs:element name="workflow" type="xs:string" minOccurs="0"/>
              <xs:element name="type" type="xs:string" minOccurs="0"/>
           </xs:all>
           <xs:attribute type="xs:string" name="id" use="optional"/>
        </xs:complexType>

<xs:complexType xmlns:xs="http://www.w3.org/2001/XMLSchema"
                        name="internalExternalOrganisationAssociations">
           <xs:sequence>
              <xs:element name="internalExternalOrganisationAssociation"
                          type="cmns:internalExternalOrganisationAssociation"
                          maxOccurs="unbounded"/>
           </xs:sequence>
        </xs:complexType>

<xs:complexType xmlns:xs="http://www.w3.org/2001/XMLSchema"
                        name="internalExternalOrganisationAssociation">
           <xs:annotation>
              <xs:documentation>Details of associated organisation which can be either internal or external</xs:documentation>
           </xs:annotation>
           <xs:choice>
              <xs:element name="organisation" type="cmns:organisation" minOccurs="0"/>
              <xs:element name="externalOrganisation"
                          type="cmns:externalOrganisation"
                          minOccurs="0"/>
           </xs:choice>
        </xs:complexType>

<xs:complexType xmlns:xs="http://www.w3.org/2001/XMLSchema" name="dataType">
           <xs:annotation>
              <xs:documentation>Details of where Pure can access the associated data for a file. This can be provided via a link to a URL that the Pure server has access to, a file path on the server or the base64 encoded byte being included in the xml file</xs:documentation>
           </xs:annotation>
           <xs:choice>
              <xs:element name="http">
                 <xs:annotation>
                    <xs:documentation>
                                Use the HTTP element to indicate that the synchronization should fetch the file from an URL.
                            </xs:documentation>
                 </xs:annotation>
                 <xs:complexType>
                    <xs:sequence>
                       <xs:element name="url" type="xs:string" minOccurs="1"/>
                    </xs:sequence>
                 </xs:complexType>
              </xs:element>
              <xs:element name="file">
                 <xs:annotation>
                    <xs:documentation>
                                Use the FILE element to indicate that the synchronization should fetch the file from the disk of the Pure installation.
                            </xs:documentation>
                 </xs:annotation>
                 <xs:complexType>
                    <xs:sequence>
                       <xs:element name="path" type="xs:string" minOccurs="1"/>
                    </xs:sequence>
                 </xs:complexType>
              </xs:element>
              <xs:element name="byte">
                 <xs:annotation>
                    <xs:documentation>
                                Use the byte element to indicate that the synchronization should fetch the base64 encoded file from base64EncodedString element
                            </xs:documentation>
                 </xs:annotation>
                 <xs:complexType>
                    <xs:sequence>
                       <xs:element name="base64EncodedString" type="xs:string" minOccurs="1"/>
                    </xs:sequence>
                 </xs:complexType>
              </xs:element>
           </xs:choice>
        </xs:complexType>

<xs:complexType xmlns:xs="http://www.w3.org/2001/XMLSchema" name="upmdocuments">
           <xs:sequence>
              <xs:element name="upmdocuments" type="cmns:upmdocument" maxOccurs="unbounded"/>
           </xs:sequence>
        </xs:complexType>

<xs:complexType xmlns:xs="http://www.w3.org/2001/XMLSchema" name="upmdocument">
           <xs:annotation>
              <xs:documentation>Details a document aligned to the unified project model format</xs:documentation>
           </xs:annotation>
           <xs:all>
              <xs:element name="type"
                          type="cmns:classification"
                          minOccurs="0"
                          default="other">
                 <xs:annotation>
                    <xs:documentation>
                                For projects use a token from classification scheme /dk/atira/pure/core/document/types. Default is other.
                                For awards the type is always other
                                For applications use a token from classification scheme /dk/atira/pure/application/document/versiontypes, default is currentversion
                                NOTE! documents on applications are only available with Award Management modules
                            </xs:documentation>
                 </xs:annotation>
              </xs:element>
              <xs:element name="file" type="cmns:dataType" minOccurs="1">
                 <xs:annotation>
                    <xs:documentation>
                                Where Pure can access the file. Can be either via a http url, file path on the server, as a base64 encoded string of the file data itself
                            </xs:documentation>
                 </xs:annotation>
              </xs:element>
              <xs:element name="mimeType" type="cmns:string_256" minOccurs="0">
                 <xs:annotation>
                    <xs:documentation>
                                The mime type of file
                            </xs:documentation>
                 </xs:annotation>
              </xs:element>
              <xs:element name="fileName" type="cmns:string_256" minOccurs="0">
                 <xs:annotation>
                    <xs:documentation>
                                The name of the file. This will be derived from the file if not specified
                            </xs:documentation>
                 </xs:annotation>
              </xs:element>
              <xs:element name="title" type="cmns:string_1024" minOccurs="0">
                 <xs:annotation>
                    <xs:documentation>
                                The title of the file
                            </xs:documentation>
                 </xs:annotation>
              </xs:element>
              <xs:element name="visibility" type="cmns:string_1024" minOccurs="0">
                 <xs:annotation>
                    <xs:documentation>
                                Visibility cannot be set on application documents.
                            </xs:documentation>
                 </xs:annotation>
              </xs:element>
           </xs:all>
           <xs:attribute type="cmns:string_512" name="id" use="required">
              <xs:annotation>
                 <xs:documentation>
                            An identifier for the document. Must be unique for the content type record
                        </xs:documentation>
              </xs:annotation>
           </xs:attribute>
        </xs:complexType>

<xs:complexType xmlns:xs="http://www.w3.org/2001/XMLSchema" name="documents">
           <xs:sequence>
              <xs:element name="documents" type="cmns:document" maxOccurs="unbounded"/>
           </xs:sequence>
        </xs:complexType>

<xs:complexType xmlns:xs="http://www.w3.org/2001/XMLSchema" name="document">
           <xs:all>
              <xs:element name="url" type="cmns:url" minOccurs="0"/>
              <xs:element name="type" type="cmns:string_1024" minOccurs="0"/>
              <xs:element name="filename" type="cmns:string_1024" minOccurs="0"/>
              <xs:element name="version" type="cmns:string_1024" minOccurs="0"/>
              <xs:element name="visibility" type="cmns:string_1024" minOccurs="0"/>
              <xs:element name="embargo_date" type="cmns:date" minOccurs="0"/>
              <xs:element name="rights" type="cmns:string_1024" minOccurs="0"/>
              <xs:element name="title" type="cmns:string_1024" minOccurs="0"/>
              <xs:element name="mimetype" type="cmns:string_1024" minOccurs="0"/>
              <xs:element name="filesize" type="cmns:string_1024" minOccurs="0"/>
              <xs:element name="digest" type="cmns:string_1024" minOccurs="0"/>
           </xs:all>
           <xs:attribute type="cmns:string_512" name="id" use="optional">
              <xs:annotation>
                 <xs:documentation>
                            An identifier for the document. Must be unique for the content type record
                        </xs:documentation>
              </xs:annotation>
           </xs:attribute>
        </xs:complexType>

<xs:complexType xmlns:xs="http://www.w3.org/2001/XMLSchema" name="url">
           <xs:all>
              <xs:element name="url" type="cmns:string_1024"/>
              <xs:element name="type" type="cmns:string_1024"/>
              <xs:element name="description" type="cmns:localized_string"/>
           </xs:all>
        </xs:complexType>

<xs:complexType xmlns:xs="http://www.w3.org/2001/XMLSchema" name="classifiedFiles">
           <xs:sequence>
              <xs:element name="classifiedFile"
                          type="cmns:classifiedFile"
                          maxOccurs="unbounded"/>
           </xs:sequence>
        </xs:complexType>

<xs:complexType xmlns:xs="http://www.w3.org/2001/XMLSchema" name="classifiedFile">
           <xs:all>
              <xs:element name="classification" type="cmns:classification" minOccurs="0"/>
              <xs:element name="fileUrl" type="cmns:string_1024">
                 <xs:annotation>
                    <xs:documentation>HTTP url where the file can be found</xs:documentation>
                 </xs:annotation>
              </xs:element>
              <xs:element name="fileName" type="xs:string" minOccurs="0"/>
              <xs:element name="mimeType" type="xs:string" minOccurs="0"/>
           </xs:all>
           <xs:attribute type="cmns:string_512" name="id"/>
        </xs:complexType>

<xs:complexType xmlns:xs="http://www.w3.org/2001/XMLSchema" name="links">
           <xs:sequence>
              <xs:element name="link"
                          type="cmns:link"
                          minOccurs="1"
                          maxOccurs="unbounded"/>
           </xs:sequence>
        </xs:complexType>

<xs:complexType xmlns:xs="http://www.w3.org/2001/XMLSchema" name="link">
           <xs:annotation>
              <xs:documentation>
                        A link of a given classification type
                    </xs:documentation>
           </xs:annotation>
           <xs:all>
              <xs:element name="url" type="xs:string">
                 <xs:annotation>
                    <xs:documentation>
                                The url of the link
                            </xs:documentation>
                 </xs:annotation>
              </xs:element>
              <xs:element name="type" type="cmns:classification" minOccurs="0">
                 <xs:annotation>
                    <xs:documentation>
                                A classification value that indicates the type of the link. The associated classification scheme depends on the content type
                            </xs:documentation>
                 </xs:annotation>
              </xs:element>
              <xs:element name="description" type="cmns:localized_string" minOccurs="0">
                 <xs:annotation>
                    <xs:documentation>
                                A free text description of the link and its purpose
                            </xs:documentation>
                 </xs:annotation>
              </xs:element>
           </xs:all>
           <xs:attribute type="cmns:string_512" name="id">
              <xs:annotation>
                 <xs:documentation>
                            An identifier for the document. Must be unique for the content type record
                        </xs:documentation>
              </xs:annotation>
           </xs:attribute>
        </xs:complexType>

<xs:complexType xmlns:xs="http://www.w3.org/2001/XMLSchema" name="compoundDate">
           <xs:annotation>
              <xs:documentation>
                        A date broken down into seperate fields for year, month and day. Only year is mandatory
                    </xs:documentation>
           </xs:annotation>
           <xs:all>
              <xs:element name="year" type="cmns:year" minOccurs="1">
                 <xs:annotation>
                    <xs:documentation>Year in four digit format (e.g. 2023)</xs:documentation>
                 </xs:annotation>
              </xs:element>
              <xs:element name="month" type="cmns:month" minOccurs="0">
                 <xs:annotation>
                    <xs:documentation>Month in two digit format</xs:documentation>
                 </xs:annotation>
              </xs:element>
              <xs:element name="day" type="cmns:day" minOccurs="0">
                 <xs:annotation>
                    <xs:documentation>The day of the month</xs:documentation>
                 </xs:annotation>
              </xs:element>
           </xs:all>
        </xs:complexType>

<xs:simpleType xmlns:xs="http://www.w3.org/2001/XMLSchema" name="year">
           <xs:annotation>
              <xs:documentation>Year in four digit format (e.g. 2023)</xs:documentation>
           </xs:annotation>
           <xs:restriction base="xs:integer">
              <xs:minInclusive value="1"/>
              <xs:maxInclusive value="9999"/>
           </xs:restriction>
        </xs:simpleType>

<xs:simpleType xmlns:xs="http://www.w3.org/2001/XMLSchema" name="month">
           <xs:annotation>
              <xs:documentation>Month in two digit format (from 1 to 12)</xs:documentation>
           </xs:annotation>
           <xs:restriction base="xs:integer">
              <xs:minInclusive value="1"/>
              <xs:maxInclusive value="12"/>
           </xs:restriction>
        </xs:simpleType>

<xs:simpleType xmlns:xs="http://www.w3.org/2001/XMLSchema" name="day">
           <xs:annotation>
              <xs:documentation>Day of the month (from 1 to 31)</xs:documentation>
           </xs:annotation>
           <xs:restriction base="xs:integer">
              <xs:minInclusive value="1"/>
              <xs:maxInclusive value="31"/>
           </xs:restriction>
        </xs:simpleType>

<xs:simpleType xmlns:xs="http://www.w3.org/2001/XMLSchema" name="date">
           <xs:annotation>
              <xs:documentation>Accepted formats for dates</xs:documentation>
           </xs:annotation>
           <xs:restriction base="xs:string">
              <xs:pattern value="[\d]{1,2}-[\w]{1,3}-[\d]{4}">
                 <xs:annotation>
                    <xs:documentation>DD-MMM-YYY format (e.g. 21-Jun-2010)</xs:documentation>
                 </xs:annotation>
              </xs:pattern>
              <xs:pattern value="[\d]{1,2}-[\d]{1,2}-[\d]{4}">
                 <xs:annotation>
                    <xs:documentation>DD-MM-YYY format (e.g. 21-06-2010)</xs:documentation>
                 </xs:annotation>
              </xs:pattern>
              <xs:pattern value="[\d]{4}-[\d]{1,2}-[\d]{1,2}[+/T]?[\d]?[\d]?[:]?[\d]?[\d]?[:]?[\d]?[\d]?[+]?[\d]?[\d]?[:]?[\d]?[\d]?">
                 <xs:annotation>
                    <xs:documentation>ISO date time format</xs:documentation>
                 </xs:annotation>
              </xs:pattern>
              <xs:pattern value="[\d]{4}-[\d]{1,2}-[\d]{1,2}[+/-]?[+/+]?[\d]?[\d]?[:]?[\d]?[\d]?[:]?[\d]?[\d]?">
                 <xs:annotation>
                    <xs:documentation>YYYY-MM-DD</xs:documentation>
                 </xs:annotation>
              </xs:pattern>
           </xs:restriction>
        </xs:simpleType>

<xs:complexType xmlns:xs="http://www.w3.org/2001/XMLSchema" name="dateRange">
           <xs:annotation>
              <xs:documentation>Indicates a period of time. To reflect an ongoing period, omit the endDate element</xs:documentation>
           </xs:annotation>
           <xs:all>
              <xs:element name="startDate" type="cmns:date">
                 <xs:annotation>
                    <xs:documentation>YYYY-MM-DD</xs:documentation>
                 </xs:annotation>
              </xs:element>
              <xs:element name="endDate" type="cmns:date" minOccurs="0">
                 <xs:annotation>
                    <xs:documentation>YYYY-MM-DD</xs:documentation>
                 </xs:annotation>
              </xs:element>
           </xs:all>
        </xs:complexType>

<xs:complexType xmlns:xs="http://www.w3.org/2001/XMLSchema" name="periode">
           <xs:annotation>
              <xs:documentation>Indicates a period of time, using compound dates, so just years can be provided</xs:documentation>
           </xs:annotation>
           <xs:sequence>
              <xs:element name="startdate" type="cmns:compoundDate" minOccurs="1"/>
              <xs:element name="enddate" type="cmns:compoundDate" minOccurs="0"/>
           </xs:sequence>
        </xs:complexType>

<xs:complexType xmlns:xs="http://www.w3.org/2001/XMLSchema" name="name">
           <xs:annotation>
              <xs:documentation>Name of a person, broken into first and last name fields</xs:documentation>
           </xs:annotation>
           <xs:all>
              <xs:element name="firstname" type="cmns:string_1024" minOccurs="0">
                 <xs:annotation>
                    <xs:documentation>The first name of the person</xs:documentation>
                 </xs:annotation>
              </xs:element>
              <xs:element name="lastname" type="cmns:string_1024" minOccurs="0">
                 <xs:annotation>
                    <xs:documentation>The last name of the person</xs:documentation>
                 </xs:annotation>
              </xs:element>
           </xs:all>
        </xs:complexType>

<xs:complexType xmlns:xs="http://www.w3.org/2001/XMLSchema" name="address">
           <xs:annotation>
              <xs:documentation>Address details, broken down into elements for the different components of the address</xs:documentation>
           </xs:annotation>
           <xs:all>
              <xs:element name="country" type="cmns:country" minOccurs="0">
                 <xs:annotation>
                    <xs:documentation>2 letter ISO code of the country</xs:documentation>
                 </xs:annotation>
              </xs:element>
              <xs:element name="road" type="cmns:string_1024" minOccurs="0">
                 <xs:annotation>
                    <xs:documentation>Free text of the street</xs:documentation>
                 </xs:annotation>
              </xs:element>
              <xs:element name="room" type="cmns:string_1024" minOccurs="0">
                 <xs:annotation>
                    <xs:documentation>Free text of the room</xs:documentation>
                 </xs:annotation>
              </xs:element>
              <xs:element name="city" type="cmns:string_1024" minOccurs="0">
                 <xs:annotation>
                    <xs:documentation>Free text of the city</xs:documentation>
                 </xs:annotation>
              </xs:element>
              <xs:element name="building" type="cmns:string_1024" minOccurs="0">
                 <xs:annotation>
                    <xs:documentation>Free text of the building</xs:documentation>
                 </xs:annotation>
              </xs:element>
              <xs:element name="postalCode" type="cmns:string_1024" minOccurs="0">
                 <xs:annotation>
                    <xs:documentation>Postal code of the address</xs:documentation>
                 </xs:annotation>
              </xs:element>
           </xs:all>
        </xs:complexType>

<xs:element xmlns:xs="http://www.w3.org/2001/XMLSchema"
                    name="subdivisionOrState"
                    abstract="true">
           <xs:annotation>
              <xs:documentation>If the country has support for subdivisions in Pure then the classification code of the subdivision should be provided, otherwise free text can be entered for the state</xs:documentation>
           </xs:annotation>
        </xs:element>

Accordion Body

Accordion Body

<xs:complexType xmlns:xs="http://www.w3.org/2001/XMLSchema" name="CERIFAddress">
           <xs:all>
              <xs:element name="address1" type="cmns:string_1024" minOccurs="0"/>
              <xs:element name="address2" type="cmns:string_1024" minOccurs="0"/>
              <xs:element name="address3" type="cmns:string_1024" minOccurs="0"/>
              <xs:element name="address4" type="cmns:string_1024" minOccurs="0"/>
              <xs:element name="address5" type="cmns:string_1024" minOccurs="0"/>
              <xs:element name="postalCode" type="cmns:string_1024" minOccurs="0"/>
              <xs:element name="city" type="cmns:string_1024" minOccurs="0"/>
              <xs:element ref="cmns:subdivisionOrState" minOccurs="0">
                 <xs:annotation>
                    <xs:documentation>If the country has subdivisions supported in Pure then the code of the subdivision classification should be provided, otherwise free text can be provided for the state</xs:documentation>
                 </xs:annotation>
              </xs:element>
              <xs:element name="country" type="cmns:classification" minOccurs="0">
                 <xs:annotation>
                    <xs:documentation>
                                Classification key from the scheme: /dk/atira/pure/core/countries
                            </xs:documentation>
                 </xs:annotation>
              </xs:element>
              <xs:element name="geoLocation" type="cmns:geoLocation" minOccurs="0">
                 <xs:annotation>
                    <xs:documentation>Geo location coordinates corresponding to the address</xs:documentation>
                 </xs:annotation>
              </xs:element>
           </xs:all>
        </xs:complexType>

<xs:complexType xmlns:xs="http://www.w3.org/2001/XMLSchema" name="classifiedAddresses">
           <xs:sequence>
              <xs:element name="classifiedAddress"
                          type="cmns:classifiedAddress"
                          maxOccurs="unbounded"/>
           </xs:sequence>
        </xs:complexType>

<xs:complexType xmlns:xs="http://www.w3.org/2001/XMLSchema" name="classifiedAddress">
           <xs:all>
              <xs:element name="addressType" type="cmns:classification">
                 <xs:annotation>
                    <xs:documentation>The type of address. Must be a valid classification from the /dk/atira/pure/person/personaddresstype classification scheme</xs:documentation>
                 </xs:annotation>
              </xs:element>
              <xs:element name="city" type="cmns:string_1024" minOccurs="0"/>
              <xs:element name="postalCode" type="cmns:string_1024" minOccurs="0"/>
              <xs:element name="street" type="cmns:string_1024" minOccurs="0"/>
              <xs:element name="country" type="cmns:country" minOccurs="0"/>
              <xs:element name="building" type="cmns:string_1024" minOccurs="0"/>
              <xs:element name="displayFormat" type="cmns:string_2048" minOccurs="0">
                 <xs:annotation>
                    <xs:documentation>A formatted version of the address, that will be used instead of the default Pure formatting</xs:documentation>
                 </xs:annotation>
              </xs:element>
              <xs:element name="subDivision" type="cmns:classification" minOccurs="0"/>
              <xs:element name="geoLocation" type="cmns:geoLocation" minOccurs="0"/>
           </xs:all>
           <xs:attribute type="cmns:string_512" name="id" use="required"/>
        </xs:complexType>

<xs:complexType xmlns:xs="http://www.w3.org/2001/XMLSchema" name="geoLocation">
           <xs:all>
              <xs:element name="point" type="cmns:string_512" minOccurs="0">
                 <xs:annotation>
                    <xs:documentation>A geospatial point. Google maps format</xs:documentation>
                 </xs:annotation>
              </xs:element>
              <xs:element name="polygon" type="xs:string" minOccurs="0">
                 <xs:annotation>
                    <xs:documentation>A geospatial polygon. Google maps format</xs:documentation>
                 </xs:annotation>
              </xs:element>
           </xs:all>
        </xs:complexType>

<xs:complexType xmlns:xs="http://www.w3.org/2001/XMLSchema" name="classifiedPhoneNumbers">
           <xs:sequence>
              <xs:element name="classifiedPhoneNumber"
                          type="cmns:classifiedPhoneNumber"
                          maxOccurs="unbounded"/>
           </xs:sequence>
        </xs:complexType>

<xs:complexType xmlns:xs="http://www.w3.org/2001/XMLSchema" name="classifiedPhoneNumber">
           <xs:annotation>
              <xs:documentation>A phone number of an associated type</xs:documentation>
           </xs:annotation>
           <xs:all>
              <xs:element name="classification" type="cmns:classification">
                 <xs:annotation>
                    <xs:documentation>The type of phone number. Must be a valid classification from the /dk/atira/pure/person/personphonenumbertype classification scheme</xs:documentation>
                 </xs:annotation>
              </xs:element>
              <xs:element name="value" type="cmns:string_64"/>
           </xs:all>
           <xs:attribute type="cmns:string_512" name="id" use="required"/>
        </xs:complexType>

<xs:complexType xmlns:xs="http://www.w3.org/2001/XMLSchema" name="classifiedEmails">
           <xs:sequence>
              <xs:element name="classifiedEmail"
                          type="cmns:classifiedEmail"
                          maxOccurs="unbounded"/>
           </xs:sequence>
        </xs:complexType>

<xs:complexType xmlns:xs="http://www.w3.org/2001/XMLSchema" name="classifiedEmail">
           <xs:all>
              <xs:element name="classification" type="cmns:classification">
                 <xs:annotation>
                    <xs:documentation>The type of email. Must be a valid classification from the /dk/atira/pure/person/personemailtype classification scheme</xs:documentation>
                 </xs:annotation>
              </xs:element>
              <xs:element name="value" type="cmns:string_256"/>
           </xs:all>
           <xs:attribute type="cmns:string_512" name="id" use="required"/>
        </xs:complexType>

<xs:complexType xmlns:xs="http://www.w3.org/2001/XMLSchema" name="classifiedWebAddresses">
           <xs:sequence>
              <xs:element name="classifiedWebAddress"
                          type="cmns:classifiedWebAddress"
                          maxOccurs="unbounded"/>
           </xs:sequence>
        </xs:complexType>

<xs:complexType xmlns:xs="http://www.w3.org/2001/XMLSchema" name="classifiedWebAddress">
           <xs:all>
              <xs:element name="classification" type="cmns:classification" minOccurs="0">
                 <xs:annotation>
                    <xs:documentation>The type of web address. Must be a valid classification from the /dk/atira/pure/person/personwebaddresstype classification scheme</xs:documentation>
                 </xs:annotation>
              </xs:element>
              <xs:element name="value" type="cmns:localized_string_1024" minOccurs="0"/>
           </xs:all>
           <xs:attribute type="cmns:string_512" name="id" use="required"/>
        </xs:complexType>

<xs:complexType xmlns:xs="http://www.w3.org/2001/XMLSchema" name="persons">
           <xs:sequence>
              <xs:element name="person" type="cmns:person" maxOccurs="unbounded"/>
           </xs:sequence>
        </xs:complexType>

<xs:complexType xmlns:xs="http://www.w3.org/2001/XMLSchema" name="person">
           <xs:sequence>
              <xs:element name="firstName" type="cmns:string_1024" minOccurs="0"/>
              <xs:element name="lastName" type="cmns:string_1024" minOccurs="0"/>
           </xs:sequence>
           <xs:attribute type="cmns:string_512" name="id" use="optional">
              <xs:annotation>
                 <xs:documentation>
                            Id of the person, this would be the id from an external source i.e. HR system.
                        </xs:documentation>
              </xs:annotation>
           </xs:attribute>
        </xs:complexType>

<xs:complexType xmlns:xs="http://www.w3.org/2001/XMLSchema" name="comments">
           <xs:annotation>
              <xs:documentation>A collection of comments against the record</xs:documentation>
           </xs:annotation>
           <xs:sequence minOccurs="1" maxOccurs="unbounded">
              <xs:element name="comment">
                 <xs:annotation>
                    <xs:documentation>Can be multiple comments, each with optional date and associated user</xs:documentation>
                 </xs:annotation>
                 <xs:complexType>
                    <xs:sequence>
                       <xs:element name="date" type="cmns:date" minOccurs="0">
                          <xs:annotation>
                             <xs:documentation>Date the comment was made</xs:documentation>
                          </xs:annotation>
                       </xs:element>
                       <xs:element name="username" type="cmns:string_256" minOccurs="0">
                          <xs:annotation>
                             <xs:documentation>Username of the person who made the comment</xs:documentation>
                          </xs:annotation>
                       </xs:element>
                       <xs:element name="text" type="cmns:string_2048">
                          <xs:annotation>
                             <xs:documentation>The text of the comment</xs:documentation>
                          </xs:annotation>
                       </xs:element>
                    </xs:sequence>
                 </xs:complexType>
              </xs:element>
           </xs:sequence>
        </xs:complexType>

<xs:simpleType xmlns:xs="http://www.w3.org/2001/XMLSchema" name="gender">
           <xs:restriction base="xs:string">
              <xs:enumeration value="male"/>
              <xs:enumeration value="female"/>
              <xs:enumeration value="unknown"/>
           </xs:restriction>
        </xs:simpleType>

<xs:element xmlns:xs="http://www.w3.org/2001/XMLSchema" name="metrics">
           <xs:annotation>
              <xs:documentation>Can add metrics to journal in Pure</xs:documentation>
           </xs:annotation>
           <xs:complexType>
              <xs:sequence maxOccurs="unbounded">
                 <xs:element name="metric">
                    <xs:complexType>
                       <xs:sequence>
                          <xs:element name="year" type="cmns:year">
                             <xs:annotation>
                                <xs:documentation>The year the metric applies to</xs:documentation>
                             </xs:annotation>
                          </xs:element>
                          <xs:element name="type" type="cmns:classification">
                             <xs:annotation>
                                <xs:documentation>The type of the metric. Should be defined in the /dk/atira/pure/source/rating classification scheme</xs:documentation>
                             </xs:annotation>
                          </xs:element>
                          <xs:element name="category" type="cmns:classification">
                             <xs:annotation>
                                <xs:documentation>The category of the metric. Should be defined in the /dk/atira/pure/source/rating classification scheme</xs:documentation>
                             </xs:annotation>
                          </xs:element>
                          <xs:element ref="cmns:metricValues">
                             <xs:annotation>
                                <xs:documentation>The values for the metric</xs:documentation>
                             </xs:annotation>
                          </xs:element>
                       </xs:sequence>
                    </xs:complexType>
                 </xs:element>
              </xs:sequence>
           </xs:complexType>

<xs:element xmlns:xs="http://www.w3.org/2001/XMLSchema" name="metricValues">
           <xs:annotation>
              <xs:documentation>
                        The specific values for the metric type and year
                    </xs:documentation>
           </xs:annotation>
           <xs:complexType>
              <xs:sequence>
                 <xs:element name="value">
                    <xs:complexType>
                       <xs:sequence>
                          <xs:element name="name" type="cmns:string_64">
                             <xs:annotation>
                                <xs:documentation>The name of the metric</xs:documentation>
                             </xs:annotation>
                          </xs:element>
                          <xs:element name="integerValue" type="xs:integer" minOccurs="0">
                             <xs:annotation>
                                <xs:documentation>The integer value for the metric</xs:documentation>
                             </xs:annotation>
                          </xs:element>
                          <xs:element name="doubleValue" type="xs:double" minOccurs="0">
                             <xs:annotation>
                                <xs:documentation>The double value (e.g. 5.2) for the metric</xs:documentation>
                             </xs:annotation>
                          </xs:element>
                          <xs:element name="stringValue" type="cmns:classification" minOccurs="0">
                             <xs:annotation>
                                <xs:documentation>The text value for the metric</xs:documentation>
                             </xs:annotation>
                          </xs:element>
                       </xs:sequence>
                    </xs:complexType>
                 </xs:element>
              </xs:sequence>
           </xs:complexType>
        </xs:element>

<xs:complexType xmlns:xs="http://www.w3.org/2001/XMLSchema" name="ids">
           <xs:sequence>
              <xs:element name="id" type="cmns:id" maxOccurs="unbounded"/>
           </xs:sequence>
        </xs:complexType>

<xs:complexType xmlns:xs="http://www.w3.org/2001/XMLSchema" name="id">
           <xs:simpleContent>
              <xs:extension base="cmns:string_512">
                 <xs:annotation>
                    <xs:documentation>The value of the id</xs:documentation>
                 </xs:annotation>
                 <xs:attribute name="type" type="cmns:classification" use="required">
                    <xs:annotation>
                       <xs:documentation>token from the classification scheme /dk/atira/pure/{family}/classifiedsource</xs:documentation>
                    </xs:annotation>
                 </xs:attribute>
                 <xs:attribute name="id" type="cmns:string_512" use="optional">
                    <xs:annotation>
                       <xs:documentation>Identification id of the classified id</xs:documentation>
                    </xs:annotation>
                 </xs:attribute>
              </xs:extension>
           </xs:simpleContent>
        </xs:complexType>

<xs:attributeGroup xmlns:xs="http://www.w3.org/2001/XMLSchema" name="id">
           <xs:attribute name="id" type="cmns:string_512" use="optional">
              <xs:annotation>
                 <xs:documentation>
                            ID of the external entity. If it is not found in Pure, an element with this ID will be created for
                            most types
                        </xs:documentation>
              </xs:annotation>
           </xs:attribute>
           <xs:attribute name="source" type="cmns:string_1024" use="optional">
              <xs:annotation>
                 <xs:documentation>
                            Source can be used to hint to Pure, when there are two entities that match during the ID search,
                            which one to prefer.
                            i.e. organisation A has a synchronised ID "1234" and organisation B was created by pure using ID
                            1234. This would cause both to match, and the source can be used to hint the correct one
                        </xs:documentation>
              </xs:annotation>
           </xs:attribute>
        </xs:attributeGroup>

<xs:attributeGroup xmlns:xs="http://www.w3.org/2001/XMLSchema" name="lookupId">
           <xs:attribute name="lookupId" type="cmns:string_1024" use="optional">
              <xs:annotation>
                 <xs:documentation>
                            ID of the entity. When using id matching, the lookup for the content is handled in the following way and order:
                            1. Pure id matching
                            2. Source id matching
                            3. Classification defined id matching
                            All the above steps are taken and the result is returned. If more than one result is matched, due to for example duplicate ids, then the first result matched will be returned.
                            If the source attribute is present then duplicate results will be resolved using the source hint
                        </xs:documentation>
              </xs:annotation>
           </xs:attribute>
           <xs:attribute name="lookupHint" type="cmns:string_1024" use="optional">
              <xs:annotation>
                 <xs:documentation>
                            Source can be used as hint to Pure on which entity should be preferred if more than one entity is matched during the ID search.
                            i.e. organisation A has a synchronised ID "1234" and organisation B was created by pure using ID
                            1234. This would cause both to match, and the source can be used to hint the correct one
                            Use pure as value if the Pure ID is preferred
                            Use the specific source as value if the id from a synchronisation is preferred, eg synchronisedUnifiedOrganisation
                            Use a key from a sources classification schema as value if the id from a specific source it preferred, eg organisationid for Organisation ID source
                        </xs:documentation>
              </xs:annotation>
           </xs:attribute>
        </xs:attributeGroup>

<xs:attributeGroup xmlns:xs="http://www.w3.org/2001/XMLSchema" name="originId">
           <xs:attributeGroup ref="cmns:lookupId"/>
           <xs:attribute name="origin"
                         type="cmns:origin"
                         use="optional"
                         default="internal">
              <xs:annotation>
                 <xs:documentation>Origin is used for to specify whether it is an internal or external person/organisation</xs:documentation>
              </xs:annotation>
           </xs:attribute>
        </xs:attributeGroup>

<xs:simpleType xmlns:xs="http://www.w3.org/2001/XMLSchema" name="origin">
           <xs:annotation>
              <xs:documentation>Indicates if the record is meant to be internal or external</xs:documentation>
           </xs:annotation>
           <xs:restriction base="cmns:string_9">
              <xs:enumeration value="internal"/>
              <xs:enumeration value="external"/>
           </xs:restriction>
        </xs:simpleType>

<xs:complexType xmlns:xs="http://www.w3.org/2001/XMLSchema" name="classifiedIdentification">
           <xs:annotation>
              <xs:documentation>An identifier used to lookup content in Pure. This can be done based on the Pure ID, the Source ID (such as used in a previous XML import) or a specifically defined classified ID. Alternatively a non_explicit_id will search against all of these for a match, which may lead to multiple records being matched.</xs:documentation>
           </xs:annotation>
           <xs:choice>
              <xs:element name="non_explicit_id" type="cmns:non_explicit_id"/>
              <xs:element ref="cmns:pure_id"/>
              <xs:element ref="cmns:source_id"/>
              <xs:element ref="cmns:classified_id"/>
           </xs:choice>
        </xs:complexType>

<xs:complexType xmlns:xs="http://www.w3.org/2001/XMLSchema" name="identification">
           <xs:annotation>
              <xs:documentation>An identifier used to lookup content in Pure. This can be done based on the Pure ID or the Source ID (such as used in a previous XML import). Alternatively a non_explicit_id will search against all of these for a match, which may lead to multiple records being matched.</xs:documentation>
           </xs:annotation>
           <xs:choice>
              <xs:element name="non_explicit_id" type="cmns:non_explicit_id"/>
              <xs:element ref="cmns:pure_id"/>
              <xs:element ref="cmns:source_id"/>
           </xs:choice>
        </xs:complexType>

<xs:complexType xmlns:xs="http://www.w3.org/2001/XMLSchema"
                        name="non_explicit_id_with_hint_for_ext_org">
           <xs:choice>
              <xs:sequence>
                 <xs:element name="id" type="cmns:non_explicit_id"/>
                 <xs:element name="hint" type="cmns:hint" minOccurs="0"/>
              </xs:sequence>
              <xs:sequence>
                 <xs:element name="name" type="cmns:string_1024"/>
                 <xs:element name="type" type="cmns:classification" minOccurs="0">
                    <xs:annotation>
                       <xs:documentation>Classification scheme /dk/atira/pure/ueoexternalorganisation/ueoexternalorganisationtypes</xs:documentation>
                    </xs:annotation>
                 </xs:element>
                 <xs:element name="country" type="cmns:classification" minOccurs="0">
                    <xs:annotation>
                       <xs:documentation>Classification scheme /dk/atira/pure/core/countries</xs:documentation>
                    </xs:annotation>
                 </xs:element>
              </xs:sequence>
           </xs:choice>
        </xs:complexType>

<xs:complexType xmlns:xs="http://www.w3.org/2001/XMLSchema"
                        name="non_explicit_id_with_hint">
           <xs:all>
              <xs:element name="id" type="cmns:non_explicit_id"/>
              <xs:element name="hint" type="cmns:hint" minOccurs="0"/>
           </xs:all>
        </xs:complexType>

<xs:simpleType xmlns:xs="http://www.w3.org/2001/XMLSchema" name="hint">
           <xs:annotation>
              <xs:documentation>Hint for the id matching. This will narrow down the range of the matching to a specific ids type. The following values are supported:
                        PURE - Matching will be limited to Pure id.
                        UUID - Matching will be limited to Pure UUID.
                        SOURCE - Matching will be limited to Pure source ids
                        CLASSIFIED_SOURCE - Matching will be limited to Pure classification defined ids
                    </xs:documentation>
           </xs:annotation>
           <xs:restriction base="xs:string">
              <xs:enumeration value="PURE"/>
              <xs:enumeration value="UUID"/>
              <xs:enumeration value="SOURCE"/>
              <xs:enumeration value="CLASSIFIED_SOURCE"/>
           </xs:restriction>
        </xs:simpleType>

<xs:simpleType xmlns:xs="http://www.w3.org/2001/XMLSchema" name="non_explicit_id">
           <xs:annotation>
              <xs:documentation>When using non explicit id matching, the lookup for the content is handled in the following way and order:
                        1. Pure id matching
                        2. Source id matching
                        3. Classification defined id matching
                        All the above steps are taken and the result is returned. If more than one result is matched, due to for example duplicate ids, then the first result matched will be returned.
                    </xs:documentation>
           </xs:annotation>
           <xs:restriction base="cmns:string_1024"/>
        </xs:simpleType>

Accordion Body

Accordion Body

Accordion Body

<xs:complexType xmlns:xs="http://www.w3.org/2001/XMLSchema" name="event">
           <xs:all>
              <xs:element name="title" type="cmns:localized_string_1024"/>
              <xs:element name="startDate" type="cmns:date"/>
           </xs:all>
           <xs:attributeGroup ref="cmns:lookupId"/>
        </xs:complexType>

<xs:complexType xmlns:xs="http://www.w3.org/2001/XMLSchema" name="simpleEvent">
           <xs:all>
              <xs:element name="title" type="cmns:string_512" minOccurs="0"/>
              <xs:element name="startDate" type="cmns:date" minOccurs="0"/>
           </xs:all>
           <xs:attributeGroup ref="cmns:lookupId"/>
        </xs:complexType>

<xs:complexType xmlns:xs="http://www.w3.org/2001/XMLSchema" name="journalOrPublisher">
           <xs:choice>
              <xs:element name="journal" type="cmns:journal"/>
              <xs:element name="publisher" type="cmns:publisher"/>
           </xs:choice>
        </xs:complexType>

<xs:complexType xmlns:xs="http://www.w3.org/2001/XMLSchema" name="journal">
           <xs:all>
              <xs:element name="title" type="cmns:string_512" minOccurs="0"/>
              <xs:element name="issn" type="cmns:string_9" minOccurs="0"/>
           </xs:all>
           <xs:attributeGroup ref="cmns:lookupId"/>
        </xs:complexType>

<xs:complexType xmlns:xs="http://www.w3.org/2001/XMLSchema" name="publisher">
           <xs:all>
              <xs:element name="name" type="cmns:string_512" minOccurs="0"/>
           </xs:all>
           <xs:attributeGroup ref="cmns:lookupId"/>
        </xs:complexType>

<xs:complexType xmlns:xs="http://www.w3.org/2001/XMLSchema"
                        name="journalOrPublisherOrEvent">
           <xs:choice>
              <xs:element name="journal" type="cmns:journal"/>
              <xs:element name="publisher" type="cmns:publisher"/>
              <xs:element name="event" type="cmns:simpleEvent"/>
           </xs:choice>
        </xs:complexType>

<xs:complexType xmlns:xs="http://www.w3.org/2001/XMLSchema" name="labelsType">
           <xs:sequence>
              <xs:element name="label" type="cmns:labelType" maxOccurs="unbounded"/>
           </xs:sequence>
        </xs:complexType>

<xs:complexType xmlns:xs="http://www.w3.org/2001/XMLSchema" name="labelType">
           <xs:all>
              <xs:element name="text" type="cmns:string_256" minOccurs="0"/>
           </xs:all>
           <xs:attribute type="cmns:string_400" name="id" use="required"/>
        </xs:complexType>