<?xml version="1.0"?>

<!--
     Copyright (C) 2004 Michel Messerschmidt. 
     All Rights reserved.
     This document may be freely used, copied and distributed
     without fee as long as it is not modified. 
-->

<xsd:schema version="1.0" xmlns:xsd="http://www.w3.org/2001/XMLSchema"
  xmlns="http://www.michel-messerschmidt.de/scl/v1"
  targetNamespace="http://www.michel-messerschmidt.de/scl/v1"
  elementFormDefault="qualified" attributeFormDefault="unqualified"
  xml:lang="en">

  <xsd:annotation>
    <xsd:appinfo>
      $Id: scl.xsd,v 1.76 2004/05/10 12:13:04 mic Exp $
    </xsd:appinfo>
    <xsd:documentation>
      This schema is the normative source of the
      "software classification language".
      Note that comments like this one are normative parts of the 
      definition and must be obeyed by conforming applications.

      The key words "MUST", "MUST NOT", "REQUIRED", "SHALL", 
      "SHALL NOT", "SHOULD", "SHOULD NOT", "RECOMMENDED",  "MAY", and
      "OPTIONAL" in this document are to be interpreted as described 
      in RFC 2119.
    </xsd:documentation>
  </xsd:annotation>


  <xsd:element name="report">
    <xsd:annotation>
      <xsd:documentation>
	This MUST be the root element for every conforming document.
      </xsd:documentation>
    </xsd:annotation>
    <xsd:complexType>
      <xsd:sequence>
	<xsd:element name="origin" type="originType"/>
	<xsd:element name="object" type="objectType" 
	  maxOccurs="unbounded"/>
      </xsd:sequence>
      <xsd:attribute name="version" type="xsd:token" default="1.0"/>
    </xsd:complexType>
  </xsd:element>


  <xsd:complexType name="originType">
    <xsd:annotation>
      <xsd:documentation>
	The "origin" element describes the origin of a report, i.e.
	where and when it was created, etc. 
	Although most of these elements are optional, it is 
	recommended to use them all.
	Note that a "creator" element is missing intentionally, 
	because only the creating program and system is needed to 
	identify the source of a report while reporting a human user
	may violate some privacy laws.
      </xsd:documentation>
    </xsd:annotation>
    <xsd:all>
      <xsd:element name="date" type="xsd:dateTime">
	<xsd:annotation>
	  <xsd:documentation>
	    This is a similiar time format as used by the XHTML 
	    standard. The general format is "YYYY-MM-DDThh:mm:ss" 
	    followed by a optional timezone specified as "Z" (for UTC),
	    "+hh:mm"  or "-hh:mm" (for the difference from UTC).

	    A timezone MUST be specified if it is known (to avoid 
	    comparison problems).
	    See "XML SChema - Datatypes" 3.2.7 for an exact type 
	    definition and algorithms to compare dateTime values.
	  </xsd:documentation>
	</xsd:annotation>
      </xsd:element>
      <xsd:element name="program" type="xsd:token">
	<xsd:annotation>
	  <xsd:documentation>
	    The program that created the report. This SHOULD be a 
	    constant value, so make sure to keep all changing 
	    attributes ("XYZ 2004") only in the "version" element.
	  </xsd:documentation>
	</xsd:annotation>
      </xsd:element>
      <xsd:element name="system" type="xsd:token" minOccurs="0">
	<xsd:annotation>
	  <xsd:documentation>
	    Used to identify the system that contains the reported 
	    software (...that is scanned).
	    It is recommended to use an IP address, hostname or 
	    NetBIOS name.
	  </xsd:documentation>
	</xsd:annotation>
      </xsd:element>
      <xsd:element name="version" type="xsd:token" minOccurs="0">
	<xsd:annotation>
	  <xsd:documentation>
	    This should be used to give the exact version of the 
	    program that created a report.
	  </xsd:documentation>
	</xsd:annotation>
      </xsd:element>
      <xsd:element name="dataversion" type="xsd:token" minOccurs="0">
	<xsd:annotation>
	  <xsd:documentation>
	    This SHOULD be used to identify the version of the 
	    data basis that is used for the classification. 
	    Antimalware products should insert the date/version of 
	    their malware definitions/patterns here.
	  </xsd:documentation>
	</xsd:annotation>
      </xsd:element>
      <xsd:element name="options" type="xsd:string" minOccurs="0">
	<xsd:annotation>
	  <xsd:documentation>
	    Should be used to give all program options and settings 
	    that are required to reproduce a report.
	  </xsd:documentation>
	</xsd:annotation>
      </xsd:element>
      <xsd:element name="contact" type="xsd:string" minOccurs="0">
	<xsd:annotation>
	  <xsd:documentation>
	    Who can be contacted (mail, phone, ...) if there are any 
	    questions about a report or the program that created the 
	    report.
	  </xsd:documentation>
	</xsd:annotation>
      </xsd:element>
    </xsd:all>
  </xsd:complexType>


  <xsd:complexType name="objectType">
    <xsd:annotation>
      <xsd:documentation>
	Each "object" element identifies and classifies a data object.
	An object may contain other objects, to provides a method to 
	classify separate parts of an data object. 
	This SHOULD NOT be used describe each data object in its 
	greatest detail but to provide only enough details to be able 
	to classsify the interesting data objects. 
      </xsd:documentation>
    </xsd:annotation>
    <xsd:sequence>
      <xsd:element name="identification" type="identificationType"/>
      <xsd:choice>
	<xsd:annotation>
	  <xsd:documentation>
	    Either this is an atomic object (for the analysis) then 
	    only a classification is required. 
	    Or this object is a container for other other objects, 
	    that must be reported within a 'content' element. 
	    No overall status report is allowed in the latter case 
	    (Although such status reports may be contructed by the 
	    interpreting program, they MUST MOT be included in this 
	    report format).
	  </xsd:documentation>
	</xsd:annotation>
	<xsd:element name="content" type="contentType"/>
	<xsd:element name="classification" type="classificationType"/>
      </xsd:choice>
    </xsd:sequence>
  </xsd:complexType>
  

  <xsd:complexType name="identificationType">
    <xsd:choice>
      <xsd:element name="file" type="fileIdentType"/>
      <xsd:element name="mail" type="mailIdentType"/>
      <xsd:element name="sector" type="sectorIdentType"/>
      <xsd:element name="packet" type="packetIdentType"/>
      <xsd:element name="memory"  type="memoryIdentType"/>
      <xsd:element name="octetstream" type="streamIdentType"/>
    </xsd:choice>
  </xsd:complexType>


  <xsd:complexType name="classificationType">
    <xsd:choice>
      <xsd:element name="malicious" type="malClassType" 
	maxOccurs="unbounded"/>
      <xsd:element name="verified" type="goodClassType"/>
      <xsd:element name="unknown" type="unknownClassType"/>
      <xsd:element name="modified" type="modifiedClassType"/>
      <xsd:element name="update" type="updateClassType"/>
    </xsd:choice>
  </xsd:complexType>


  <xsd:complexType name="contentType">
    <xsd:sequence>
      <xsd:element name="header" minOccurs="0">
	<xsd:complexType>
	  <xsd:sequence>
	    <xsd:element name="classification" 
	      type="classificationType"/>
	  </xsd:sequence>
	</xsd:complexType>
      </xsd:element>
      <xsd:element name="object" type="objectType" 
	maxOccurs="unbounded">
	<xsd:annotation>
	  <xsd:documentation>
	    Each content element MUST contain at least one object.
	  </xsd:documentation>
	</xsd:annotation>
      </xsd:element>
    </xsd:sequence>
  </xsd:complexType>
  



  <xsd:annotation>
    <xsd:documentation>
      And now all identification types:
    </xsd:documentation>
  </xsd:annotation>

  <xsd:complexType name="fileIdentType">
    <xsd:sequence>
      <xsd:choice>
	<xsd:element name="uri" type="fileURI">
	  <xsd:annotation>
	    <xsd:documentation>
	      Use this to report files by an well-formed URI 
	      (as defined in RFC 2396) with the "file" scheme
	      (defined in RFC 1738).
	    </xsd:documentation>
	  </xsd:annotation>
	</xsd:element>
	<xsd:sequence>
	  <xsd:element name="name" type="nonEmptyString">
	    <xsd:annotation>
	      <xsd:documentation>
		"name" and "path" should be used to report a filename 
		and its (absolute) path separatly.

		If it not possible to use separate elements, the 
		complete path and filename may be reported in the name 
		element (although that SHOULD be avoided). There MUST 
		be no path element in this case.

		Note 1: Linebreaks are treated as part of the filename 
		(like any other character too), because of the "string" 
		datatype.
		
		Note 2: It is not required that the path ends with 
		a path separator (for example "\"). For correct 
		interpretation, it may be necessary to insert a path 
		separator between the contents of the "path" and the 
		"name" element.
	      </xsd:documentation>
	    </xsd:annotation>
	  </xsd:element>
	  <xsd:element name="path" type="nonEmptyString" minOccurs="0"/>
	</xsd:sequence>
      </xsd:choice>
      <xsd:element name="mimetype" type="mimeDatatype" minOccurs="0"/>
      <xsd:element name="creationtime" type="xsd:dateTime" 
	minOccurs="0"/>
      <xsd:element name="modificationtime" type="xsd:dateTime"
	minOccurs="0"/>   
      <xsd:element name="accesstime" type="xsd:dateTime" 
	minOccurs="0"/>
      <xsd:element name="length" type="xsd:nonNegativeInteger" 
	minOccurs="0">
	<xsd:annotation>
	  <xsd:documentation>
	    Length of this file in bytes.
	  </xsd:documentation>
	</xsd:annotation>
      </xsd:element>
      <xsd:element name="checksum" type="checksumType" minOccurs="0"
	maxOccurs="99"/>
    </xsd:sequence>
  </xsd:complexType>


  <xsd:complexType name="mailIdentType">
    <xsd:sequence>
      <xsd:element name="header" minOccurs="0" maxOccurs="unbounded">
	<xsd:annotation>
	  <xsd:documentation>
	    Contains a mail header field as specified in RFC 2822 
	    (including the non-ASCII header extensions defined in 
	    RFC 2047).
	    Header fields included here MUST be handled unfolded, 
	    because all whitespace characters (space = #x20, 
	    tab = #x09, LF = #x0A, CR = #x0D) will be replaced with 
	    space (#x20) by the XML parser.

	    The most interesting headers for complete messages are 
	    "Message-ID" and "Date". For messages in MIME format it 
	    is recommended to include the header 
	    "Content-Transfer-Encoding".

	    For MIME messageparts (only "Content-"... headers exist), 
	    it is recommended to include "Content-Transfer-Encoding".

	    There is a separate element available for the 
	    "Content-Type" header because it is considered more 
	    important.

	    Note that the implementation here allows headers that are 
	    illegal for RFC 2822 and RFC 822 because violations of 
	    these standards occur in current mail usage.
	  </xsd:documentation>
	</xsd:annotation>
	<xsd:simpleType>
	  <xsd:restriction base="xsd:normalizedString">
	    <xsd:pattern value="[^:]+:.*"/>
	  </xsd:restriction>
	</xsd:simpleType>
      </xsd:element>
      <xsd:element name="mimetype" type="mimeDatatype">
	<xsd:annotation>
	  <xsd:documentation>
	    MIME type of a mail body or a bodypart (as defined in 
	    RFC 2045-2049).
	    Because the "Content-Type" header is considered most 
	    important for classification, its value SHOULD be included 
	    here and not in another header element. Note that 
	    parameters are not allowed to be included here. If a 
	    parameter is important for the identification or 
	    classification of a mail body, it may be reported with the
	    "mimeparameter" element (see below).
	    
	    If it is known that the "Content-Type" header is forged, the
	    correct value SHOULD be used here. This is the only case, 
	    where it is useful to include an additional header element
	    with the forged header.

	    If no MIME type is known, the default type "text/plain" 
	    SHOULD be used (in accordance with RFC 2045, 5.2).
	  </xsd:documentation>
	</xsd:annotation>
      </xsd:element>
      <xsd:element name="mimeparameter" minOccurs="0" maxOccurs="unbounded">
	<xsd:annotation>
	  <xsd:documentation>
	    This may be used to report important parameters that are 
	    appended to the MIME type in a "Content-Type" header.
	    Commonly used parameters include "charset" for "text" types
	    and "boundary" for "multipart" types.
	    if there is no "charset" parameter for a "text" type, the 
	    default value "charset=us-ascii" may be asssumed.

	    The "boundary" parameter is only useful, if the bodyparts 
	    of a multipart message are reported withon a "content" 
	    element.

	    As with the header implementation, this implementation has 
	    much less restrictions than the RFCs due to current 
	    practice.
	  </xsd:documentation>
	</xsd:annotation>
	<xsd:simpleType>
	  <xsd:restriction base="xsd:normalizedString">
	    <xsd:pattern value="[^=]+=.*"/>
	  </xsd:restriction>
	</xsd:simpleType>
      </xsd:element>
      <xsd:element name="length" type="xsd:nonNegativeInteger" 
	minOccurs="0"> 
	<xsd:annotation>
	  <xsd:documentation>
	    The length of the mail body (excluding any headers) 
	    in bytes.
	  </xsd:documentation>
	</xsd:annotation>
      </xsd:element>
      <xsd:element name="checksum" type="checksumType" 
	minOccurs="0" maxOccurs="99">
	<xsd:annotation>
	  <xsd:documentation>
	    A checksum of the mail body (excluding any headers).
	  </xsd:documentation>
	</xsd:annotation>
      </xsd:element>
    </xsd:sequence>
  </xsd:complexType>


  <xsd:complexType name="sectorIdentType">
    <xsd:sequence>
      <xsd:element name="device" type="xsd:token">
	<xsd:annotation>
	  <xsd:documentation>
	    This specifies the physical device of this sector.
	    Examples: "hda", "fd0", "multi(0)disk(0)rdisk(0)"
	    or "disk drive a:"
	    More detailed specifications (e.g. "hda5") are allowed.
	  </xsd:documentation>
	</xsd:annotation>
      </xsd:element>
      <xsd:choice>
	<xsd:element name="mbr">
	  <xsd:complexType>
	    <xsd:sequence>
	      <xsd:element name="startaddress" type="sectorAddressType"
		minOccurs="0"/>
	    </xsd:sequence>
	  </xsd:complexType>
	</xsd:element>
	<xsd:element name="single">
	  <xsd:complexType>
	    <xsd:sequence>
	      <xsd:element name="startaddress" 
		type="sectorAddressType"/>
	    </xsd:sequence>
	  </xsd:complexType>
	</xsd:element>
	<xsd:sequence>
	  <xsd:element name="boot">
	    <xsd:complexType>
	      <xsd:sequence>
		<xsd:element name="startaddress" 
		  type="sectorAddressType"/>
		<xsd:element name="endaddress" type="sectorAddressType"
		  minOccurs="0"/>
	      </xsd:sequence>
	    </xsd:complexType>
	  </xsd:element>
	  <xsd:element name="count" type="xsd:positiveInteger">
	    <xsd:annotation>
	      <xsd:documentation>
		Number of sectors in this object including 
		startaddress and endaddress.
	      </xsd:documentation>
	    </xsd:annotation>
	  </xsd:element>
	</xsd:sequence>
	<xsd:sequence>
	  <xsd:element name="chain" maxOccurs="unbounded">
	    <xsd:complexType>
	      <xsd:sequence>
		<xsd:element name="startaddress" 
		  type="sectorAddressType"/>
		<xsd:element name="endaddress" 
		  type="sectorAddressType"/>
	      </xsd:sequence>
	    </xsd:complexType>
	  </xsd:element>
	  <xsd:element name="count" type="xsd:positiveInteger">
	    <xsd:annotation>
	      <xsd:documentation>
		Number of sectors in this object including 
		startaddress and endaddress.
	      </xsd:documentation>
	    </xsd:annotation>
	  </xsd:element>
	</xsd:sequence>
      </xsd:choice>
      <xsd:element name="description" type="xsd:token" minOccurs="0">
	<xsd:annotation>
	  <xsd:documentation>
	    Possibility to add a description of this data object 
	    (for example: "partition table", "BIOS Parameter Block" 
	     or "Master File Table").
	  </xsd:documentation>
	</xsd:annotation>
      </xsd:element>
      <xsd:element name="checksum" type="checksumType" minOccurs="0"
	maxOccurs="99"/>
    </xsd:sequence>
    <xsd:attribute name="size" type="xsd:positiveInteger" 
      default="512">
      <xsd:annotation>
	<xsd:documentation>
	  Sector length in bytes.
	</xsd:documentation>
      </xsd:annotation>
    </xsd:attribute>
  </xsd:complexType>
  

  <xsd:complexType name="sectorAddressType">
    <xsd:sequence>
      <xsd:element name="lba" type="xsd:nonNegativeInteger">
	<xsd:annotation>
	  <xsd:documentation>
	    The "Logical Block Address" (LBA) of this sector.
	    To be compatible with the current LBA standard, 
	    64 bit values must be supported.
	  </xsd:documentation>
	</xsd:annotation>
      </xsd:element>
      <xsd:element name="chs" minOccurs="0">
	<xsd:annotation>
	  <xsd:documentation>
	    The old C/H/S disk sector addressing method.
	    ATA-5 restricts cylinder values to 16 bit, 
	    head values to 4 bit and sector values to 8 bit.
	    This datatype allows bigger values to make this 
	    addressing method useful for other disktypes too.
	  </xsd:documentation>
	</xsd:annotation>
	<xsd:complexType>
	  <xsd:sequence>
	    <xsd:element name="diskCylinder" type="xsd:unsignedInt"/>
	    <xsd:element name="diskHead" type="xsd:unsignedByte"/>
	    <xsd:element name="diskSector" type="xsd:unsignedShort"/>
	  </xsd:sequence>
	</xsd:complexType>
      </xsd:element>
    </xsd:sequence>
  </xsd:complexType>


  <xsd:complexType name="packetIdentType">
    <xsd:sequence>
      <xsd:choice maxOccurs="unbounded">
	<xsd:element name="single">
	  <xsd:complexType>
	    <xsd:sequence>
	      <xsd:group ref="packetStruct"/>
	      <xsd:element name="checksum" type="checksumType" 
		minOccurs="0" maxOccurs="99"/>
	    </xsd:sequence>
	  </xsd:complexType>
	</xsd:element>
	<xsd:element name="sequence">
	  <xsd:complexType>
	    <xsd:sequence>
	      <xsd:group ref="packetStruct"/>
	      <xsd:element name="count" type="xsd:positiveInteger">
		<xsd:annotation>
		  <xsd:documentation>
		    Number of packets in this object.
		  </xsd:documentation>
		</xsd:annotation>
	      </xsd:element>
	      <xsd:element name="checksum" type="checksumType" 
		minOccurs="0" maxOccurs="99"/>
	    </xsd:sequence>
	  </xsd:complexType>
	</xsd:element>
      </xsd:choice>
    </xsd:sequence>
  </xsd:complexType>

  <xsd:group name="packetStruct">
    <xsd:sequence>
      <xsd:element name="protocol" type="xsd:NMTOKEN">
	<xsd:annotation>
	  <xsd:documentation>
	    The name of the network protocol. May not include most 
	    punctuation characters (similar to XML element names).
	    A common name SHOULD be used (Examples: "http", "dns", 
	    "tcp", "icmp", "arp").
	  </xsd:documentation>
	</xsd:annotation>
      </xsd:element>
      <xsd:element name="source" type="packetAddressType" 
	minOccurs="0"/>
      <xsd:element name="destination" type="packetAddressType" 
	minOccurs="0"/>
      <xsd:element name="time" type="xsd:dateTime" minOccurs="0">
	<xsd:annotation>
	  <xsd:documentation>
	    Timestamp when this packet was received or captured.
	    For packet sequences, this is the timestamp of the first 
	    packet.
	    Some application may require specification of fractions 
	    of a second although this is optional for the 
	    "xsd:dateTime" datatype.
	  </xsd:documentation>
	</xsd:annotation>
      </xsd:element>
      <xsd:element name="length" type="xsd:positiveInteger"
	minOccurs="0">
	<xsd:annotation>
	  <xsd:documentation>
	    Packet length in bytes. 
	    For a sequence of packets this must be the sum of all 
	    paket lengths.
	  </xsd:documentation>
	</xsd:annotation>
      </xsd:element>
    </xsd:sequence>
  </xsd:group>
  
  <xsd:complexType name="packetAddressType">
    <xsd:sequence>
      <xsd:element name="interface" minOccurs="0">
	<xsd:complexType>
	  <xsd:choice>
	    <xsd:element name="mac" type="macAddress">
	      <xsd:annotation>
		<xsd:documentation>
		  The MAC address MUST be given as a hexadecimal value
		  (for example "123456789abc" for the MAC address
		  "12:34:56:78:9a:bc").
		</xsd:documentation>
	      </xsd:annotation>
	    </xsd:element>
	    <xsd:element name="eui64" type="eui64Address">
	      <xsd:annotation>
		<xsd:documentation>
		  The IETF EUI-64 address.
		</xsd:documentation>
	      </xsd:annotation>
	    </xsd:element>
	    <xsd:element name="other" type="xsd:token">
	      <xsd:annotation>
		<xsd:documentation>
		  Other interface identifiers may be given with this 
		  element.
		</xsd:documentation>
	      </xsd:annotation>
	    </xsd:element>
	  </xsd:choice>
	</xsd:complexType>
      </xsd:element>
      <xsd:element name="host">
	<xsd:complexType>
	  <xsd:choice>
	    <xsd:element name="ip" type="ipAddress">
	      <xsd:annotation>
		<xsd:documentation>
		  The IP address MUST be given in hexadecimal 
		  ("c0a82a00") or dotted-decimal format 
		  ("192.168.42.0").
		</xsd:documentation>
	      </xsd:annotation>
	    </xsd:element>
	    <xsd:element name="ipv6" type="ipv6Address">
	      <xsd:annotation>
		<xsd:documentation>
		  The IPv6 address MUST be given as hexadecimal value
		  or in a format defined in RFC 2372 (see declaration 
		  of datatype "ipv6adddress for examples).
		</xsd:documentation>
	      </xsd:annotation>
	    </xsd:element>
	    <xsd:element name="dnsname" type="xsd:NMTOKEN">
	      <xsd:annotation>
		<xsd:documentation>
		  The DNS hostname
		</xsd:documentation>
	      </xsd:annotation>
	    </xsd:element>
	    <xsd:element name="winsname" type="xsd:token">
	      <xsd:annotation>
		<xsd:documentation>
		  The WINS / NetBIOS hostname.
		</xsd:documentation>
	      </xsd:annotation>
	    </xsd:element>
	    <xsd:element name="other" type="xsd:token">
	      <xsd:annotation>
		<xsd:documentation>
		  Any other host identification method.
		</xsd:documentation>
	      </xsd:annotation>
	    </xsd:element>
	  </xsd:choice>
	</xsd:complexType>
      </xsd:element>
      <xsd:element name="service" type="xsd:NMTOKEN" minOccurs="0">
	<xsd:annotation>
	  <xsd:documentation>
	    The service address SHOULD be specified by a common 
	    service name ("http") or as a decimal port number 
	    (for example "80" for http).
	  </xsd:documentation>
	</xsd:annotation>
      </xsd:element>
    </xsd:sequence>
  </xsd:complexType>


  <xsd:complexType name="memoryIdentType">
    <xsd:sequence>
      <xsd:element name="startaddress" type="xsd:token">
      </xsd:element>
      <xsd:element name="endaddress" type="xsd:token" minOccurs="0"/>
      <xsd:element name="length" type="xsd:positiveInteger">
	<xsd:annotation>
	  <xsd:documentation>
	    Length of this memory range in bytes. This includes the
	    startaddress and the endaddress.
	  </xsd:documentation>
	</xsd:annotation>
      </xsd:element>
      <xsd:element name="description" type="xsd:token" minOccurs="0">
	<xsd:annotation>
	  <xsd:documentation>
	    Possibility to add a description of this data object.
	  </xsd:documentation>
	</xsd:annotation>
      </xsd:element>
      <xsd:element name="checksum" type="checksumType" minOccurs="0"
	maxOccurs="99"/>
    </xsd:sequence>
  </xsd:complexType>
  

  <xsd:complexType name="streamIdentType">
    <xsd:sequence>
      <xsd:element name="source" type="xsd:token" minOccurs="0"/>
      <xsd:element name="destination" type="xsd:token" minOccurs="0"/>
      <xsd:element name="length" type="xsd:positiveInteger">
	<xsd:annotation>
	  <xsd:documentation>
	    Length of this octectstream in bytes.
	  </xsd:documentation>
	</xsd:annotation>
      </xsd:element>
      <xsd:element name="mimetype" type="mimeDatatype" minOccurs="0"/>
      <xsd:element name="description" type="xsd:token" minOccurs="0">
	<xsd:annotation>
	  <xsd:documentation>
	    Possibility to add a description of this data object.
	  </xsd:documentation>
	</xsd:annotation>
      </xsd:element>
      <xsd:element name="checksum" type="checksumType" maxOccurs="99"/>
    </xsd:sequence>
  </xsd:complexType>


  
  <xsd:annotation>
    <xsd:documentation>
      And now all classification types:
    </xsd:documentation>
  </xsd:annotation>

  <xsd:complexType name="malClassType">
    <xsd:annotation>
      <xsd:documentation>
	There are different possibilities to give a classification
	for a malicious object:
	  - use an ID from a database like CVE or Bugtraq
	  - use a CARO name 
	  - use different elements to specify the various name parts:
	    type, platform, (familiy) name, variant and (all other) 
	    modifiers. It is possible to use only some of these parts.
	  - use only the "malwarename" element with arbitrary content.
	    This is NOT RECOMMENDED because it hides the internal name
	    structure and requires more external logic to interpret
	    such reports correctly.
      </xsd:documentation>
    </xsd:annotation>
    <xsd:sequence>
      <xsd:choice>
	<xsd:element name="id">
	  <xsd:annotation>
	    <xsd:documentation>
	      May be used to specify an ID of a malware or vulnerability
	      database (for example a CVE or Bugtraq ID).
	      The attribute "type" MUST identify the database.
	    </xsd:documentation>
	  </xsd:annotation>
	  <xsd:complexType>
	    <xsd:simpleContent>
	      <xsd:extension base="xsd:token">
		<xsd:attribute name="type" type="xsd:token" 
		  use="required"/>
	      </xsd:extension>
	    </xsd:simpleContent>
	  </xsd:complexType>
	</xsd:element>
	<xsd:element name="caroname" type="caroNameType"/>
	<xsd:sequence>
	  <xsd:element name="mwtype" type="noSpaceToken" minOccurs="0">
	    <xsd:annotation>
	      <xsd:documentation>
		One of the following strings SHOULD be used 
		(if appropriate):
		  virus
		  worm
		  intended
		  trojan
		  generator
		  dropper
	      </xsd:documentation>
	    </xsd:annotation>
	  </xsd:element>
	  <xsd:element name="mwplatform" type="noSpaceToken" 
	    minOccurs="0"> 
	    <xsd:annotation>
	      <xsd:documentation>
		One of the common names or abbreviations for 
		malware platforms SHOULD be used (as listed in the
		revised CARO naming scheme).
	      </xsd:documentation>
	    </xsd:annotation>
	  </xsd:element>
	  <xsd:element name="mwname" type="xsd:token">
	    <xsd:annotation>
	      <xsd:documentation>
		If used together with all other name part elements, this
		SHOULD contain only the malware family.
		"unknown" MUST be used as name for any malware that 
		can't be identified by a more exact name.
		
		Although whitespace is allowed in malware names for 
		compatibility reasons, it SHOULD NOT be used without 
		very good reason. 
	      </xsd:documentation>
	    </xsd:annotation>
	  </xsd:element>
	  <xsd:element name="mwvariant" type="noSpaceToken" 
	    minOccurs="0">
	    <xsd:annotation>
	      <xsd:documentation>
		Variants are commonly enumerated by using uppercase 
		letters: A, B, ..., Z, AA, AB, .., ZZ, AAA, ...
	      </xsd:documentation>
	    </xsd:annotation>
	  </xsd:element>
	  <xsd:element name="mwmodifier" type="noSpaceToken" 
	    minOccurs="0" maxOccurs="unbounded">
	    <xsd:annotation>
	      <xsd:documentation>
		This should be used for any other name parts 
		like @mm suffixes, language codes, etc.
	      </xsd:documentation>
	    </xsd:annotation>
	  </xsd:element>
	</xsd:sequence>
      </xsd:choice>
      <xsd:element name="property" type="xsd:token" minOccurs="0" 
	maxOccurs="unbounded">
	<xsd:annotation>
	  <xsd:documentation>
	    This is a possibility to report other object properties, 
	    that are considered important.
	  </xsd:documentation>
	</xsd:annotation>
      </xsd:element>
    </xsd:sequence>
    <xsd:attribute name="method" type="mwMethodType" 
      default="exact identification">
	<xsd:annotation>
	  <xsd:documentation>
	    The method used to detect or identify this malware.
	  </xsd:documentation>
	</xsd:annotation>
    </xsd:attribute>
  </xsd:complexType>
  

  <xsd:simpleType name="mwMethodType">
    <xsd:restriction base="xsd:token">
      <xsd:enumeration value="exact identification"/>
      <xsd:enumeration value="generic identification"/>
      <xsd:enumeration value="heuristic detection"/>
      <xsd:enumeration value="other"/>
    </xsd:restriction>
  </xsd:simpleType>


  <xsd:simpleType name="caroNameType">
    <xsd:annotation>
      <xsd:documentation>
	This datatype is based on the revised CARO naming scheme 
	(as published by Nick FitzGerald in Virus Bulletin Jan 2003).
	The complete structure must match the syntax:
	  TYPE://PLATFORM/FAMILY.GROUP.VARIANT[MODIFIERS]
	Every name part may contain only the characters: A-Za-z0-9_-
	Allowed modifiers are (in this order):
	:LOCALE
	#PACKER
	@M or @MM
	!VENDOR_SPECIFIC_COMMENT

	The following regular expressions are used for the name parts:
	TYPE, PLATFORM, FAMILY, GROUP, PACKER: [-_A-Za-z0-9]{1,20}
	LOCALE: ([A-Za-z]{2}|[Uu][Nn][Ii])
	VARIANT: (Inflen|SubvarDevo?)
	Inflen: [0-9]{1,20}
	Subvar: [A-Za-z]{1,20}
	Devo: [0-9]{1,20}
	@M[M]: @[Mm][Mm]?
	VENDOR_SPECIFIC_COMMENT: .*

	Multiple TYPE or PLATFORM parts may be given as comma-separated 
	list that is enclosed in braces (defined by the additional 
	patterns).
      </xsd:documentation>
    </xsd:annotation>
    <xsd:restriction base="noSpaceToken">
      <xsd:pattern value="[-_A-Za-z0-9]{1,20}://[-_A-Za-z0-9]{1,20}/[-_A-Za-z0-9]{1,20}(\.[-_A-Za-z0-9]{1,20})?\.([0-9]{1,20}|[A-Za-z]{1,20}[0-9]{0,20})((:([A-Za-z]{2}|[Uu][Nn][Ii]))?(#[-_A-Za-z0-9]{1,20})?(@[Mm][Mm]?)?(!.*)?)?"/>
      <xsd:pattern value="[-_A-Za-z0-9]{1,20}://\{[-_A-Za-z0-9]{1,20}(,[-_A-Za-z0-9]{1,20})+\}/[-_A-Za-z0-9]{1,20}(\.[-_A-Za-z0-9]{1,20})?\.([0-9]{1,20}|[A-Za-z]{1,20}[0-9]{0,20})((:([A-Za-z]{2}|[Uu][Nn][Ii]))?(#[-_A-Za-z0-9]{1,20})?(@[Mm][Mm]?)?(!.*)?)?"/>
      <xsd:pattern value="\{[-_A-Za-z0-9]{1,20}(,[-_A-Za-z0-9]{1,20})+\}://[-_A-Za-z0-9]{1,20}/[-_A-Za-z0-9]{1,20}(\.[-_A-Za-z0-9]{1,20})?\.([0-9]{1,20}|[A-Za-z]{1,20}[0-9]{0,20})((:([A-Za-z]{2}|[Uu][Nn][Ii]))?(#[-_A-Za-z0-9]{1,20})?(@[Mm][Mm]?)?(!.*)?)?"/>
      <xsd:pattern value="\{[-_A-Za-z0-9]{1,20}(,[-_A-Za-z0-9]{1,20})+\}://\{[-_A-Za-z0-9]{1,20}(,[-_A-Za-z0-9]{1,20})+\}/[-_A-Za-z0-9]{1,20}(\.[-_A-Za-z0-9]{1,20})?\.([0-9]{1,20}|[A-Za-z]{1,20}[0-9]{0,20})((:([A-Za-z]{2}|[Uu][Nn][Ii]))?(#[-_A-Za-z0-9]{1,20})?(@[Mm][Mm]?)?(!.*)?)?"/>
    </xsd:restriction>
  </xsd:simpleType>


  <xsd:complexType name="goodClassType">
    <xsd:annotation>
      <xsd:documentation>
	WARNING: Because this is something not in use today,
	the structure and datatype contained here MAY change
	in future versions
      </xsd:documentation>
    </xsd:annotation>
    <xsd:sequence>
      <xsd:element name="type" type="xsd:token" minOccurs="0">
	<xsd:annotation>
	  <xsd:documentation>
	    This optional element may be used together with the 
	    element "name" to give hints about the purpose/usage of
	    this software object on the computer system.
	  </xsd:documentation>
	</xsd:annotation>
      </xsd:element>
      <xsd:element name="name" type="xsd:token" minOccurs="0">
	<xsd:annotation>
	  <xsd:documentation>
	    This optional element may be used together with the 
	    element "type" to give hints about the purpose/usage of
	    this software object on the computer system.
	  </xsd:documentation>
	</xsd:annotation>
      </xsd:element>
      <xsd:element name="method" type="xsd:token">
	<xsd:annotation>
	  <xsd:documentation>
	    The verification method. For example "certificate" or 
	    "checksum"
	  </xsd:documentation>
	</xsd:annotation>
      </xsd:element>
      <xsd:element name="trustbase" type="xsd:token">
	<xsd:annotation>
	  <xsd:documentation>
	    Identifies the data basis, that is used to verify the 
	    software object.
	    For example the issuer of a certificate, if you're 
	    verifing software by cryptographic signatures.
	  </xsd:documentation>
	</xsd:annotation>
      </xsd:element>
    </xsd:sequence>
  </xsd:complexType>


  <xsd:complexType name="unknownClassType">
    <xsd:sequence>
      <xsd:element name="property" minOccurs="0" maxOccurs="unbounded">
	<xsd:annotation>
	  <xsd:documentation>
	    This is a possibility to specify the presence or absence of
	    known security relevant object properties. 
	    Example properties: 
	      "not infected"
	      "not analysed"
	      "may be a corrupted file"
	      "contains inactive malicious code fragments"
	      "signature verification failed"

	    NOTE: "not analysed" has the special meaning, that the 
	          data object has not been analysed. This property 
	          MUST be used, whenever there was a problem analysing
	          a data object.

	          "not infected" SHOULD be used if it is desired to 
	          report objects that are found to be "clean" (which 
	          means that the analysis is sufficient to be sure that
	          the object is not infected by some replicating 
	          malware). This is similar to the "ok" messages used 
	          by many antimalware products.
	  </xsd:documentation>
	</xsd:annotation>
	<xsd:complexType>
	  <xsd:simpleContent>
	    <xsd:extension base="xsd:token">
	      <xsd:attribute name="reason" use="optional">
		<xsd:annotation>
		  <xsd:documentation>
		    This SHOULD always be used if an object can not be
		    analysed. Examples:
		      "compression format not supported"
		      "object is encrypted"
		      "time limit reached"
		      "size limit reached"
		  </xsd:documentation>
		</xsd:annotation>
	      </xsd:attribute>
	    </xsd:extension>
	  </xsd:simpleContent>
	</xsd:complexType>
      </xsd:element>
    </xsd:sequence>
  </xsd:complexType>


  <xsd:complexType name="modifiedClassType">
    <xsd:sequence>
      <xsd:sequence maxOccurs="unbounded">
	<xsd:element name="found" type="xsd:token" >
	  <xsd:annotation>
	    <xsd:documentation>
	      Report a modified object property here.
	    </xsd:documentation>
	  </xsd:annotation>
	</xsd:element>
	<xsd:element name="expected" type="xsd:token">
	  <xsd:annotation>
	    <xsd:documentation>
	      Report the expected value here.
	    </xsd:documentation>
	  </xsd:annotation>
	</xsd:element>
      </xsd:sequence>
      <xsd:element name="method" type="xsd:token">
	<xsd:annotation>
	  <xsd:documentation>
	    The verification method. For example: "checksum"
	  </xsd:documentation>
	</xsd:annotation>
      </xsd:element>
      <xsd:element name="base" type="xsd:token">
	<xsd:annotation>
	  <xsd:documentation>
	    Identifies the base of the modification checks against 
	    which the objects where checked. For example:
	    "local database" or "online catalogue"
	  </xsd:documentation>
	</xsd:annotation>
      </xsd:element>
    </xsd:sequence>
  </xsd:complexType>


  <xsd:complexType name="updateClassType">
    <xsd:sequence>
      <xsd:element name="current" type="xsd:token">
	<xsd:annotation>
	  <xsd:documentation>
	    Identify the curently installed version.
	  </xsd:documentation>
	</xsd:annotation>
      </xsd:element>
      <xsd:element name="new" type="xsd:token">
	<xsd:annotation>
	  <xsd:documentation>
	    Identify the up-to-date version.
	  </xsd:documentation>
	</xsd:annotation>
      </xsd:element>
      <xsd:element name="location" type="xsd:anyURI" minOccurs="0">
	<xsd:annotation>
	  <xsd:documentation>
	    Location where the update is available.
	  </xsd:documentation>
	</xsd:annotation>
      </xsd:element>
      <xsd:element name="method" type="xsd:token">
	<xsd:annotation>
	  <xsd:documentation>
	    The method used to determine pending updates. 
	    For example: "checksum" or "version number"
	  </xsd:documentation>
	</xsd:annotation>
      </xsd:element>
      <xsd:element name="base" type="xsd:token">
	<xsd:annotation>
	  <xsd:documentation>
	    Identifies the source of the list of up-to-date objects.
	    For example: "online catalogue"
	  </xsd:documentation>
	</xsd:annotation>
      </xsd:element>
    </xsd:sequence>
  </xsd:complexType>




  <xsd:annotation>
    <xsd:documentation>
      Here are customized datatypes for attribute values and 
      simple element content.
    </xsd:documentation>
  </xsd:annotation>


  <xsd:simpleType name="nonEmptyString">
    <xsd:annotation>
      <xsd:documentation>
	Defines a string that must contain at least one character.
	This is used to exclude only the emtpy string from the 
	value space.
      </xsd:documentation>
    </xsd:annotation>
    <xsd:restriction base="xsd:string">
      <xsd:minLength value="1"/>
    </xsd:restriction>
  </xsd:simpleType>


  <xsd:simpleType name="noSpaceToken">
    <xsd:annotation>
      <xsd:documentation>
	Defines a string without any whitespace characters ("space",
	"tab","line feed" and "carriage return").
      </xsd:documentation>
    </xsd:annotation>
    <xsd:restriction base="xsd:token">
      <xsd:pattern value="\S*"/>
    </xsd:restriction>
  </xsd:simpleType>


  <xsd:simpleType name="hexNumber">
    <xsd:annotation>
      <xsd:documentation>
	Defines a hexadecimal number. Uppercase and lowercase letters 
	are allowed as well as leading zeros.
	Note that this definition includes decimal numbers.
      </xsd:documentation>
    </xsd:annotation>
    <xsd:restriction base="xsd:token">
      <xsd:pattern value="[0-9a-fA-F]+"/>
    </xsd:restriction>
  </xsd:simpleType>


  <xsd:simpleType name="macAddress">
    <xsd:annotation>
      <xsd:documentation>
	Defines a 48-bit MAC interface address either as a single 
	hexadecimal value or as hexadecimal byte values separated by 
	colon or hyphen (for example "12:34:56:78:9A:BC").
      </xsd:documentation>
    </xsd:annotation>
    <xsd:restriction base="xsd:token">
      <xsd:pattern value="[0-9a-fA-F]{12}"/>
      <xsd:pattern value="[0-9a-fA-F]{2}([-:][0-9a-fA-F]{2}){5}"/>
    </xsd:restriction>
  </xsd:simpleType>


  <xsd:simpleType name="eui64Address">
    <xsd:annotation>
      <xsd:documentation>
	Defines a 64-bit EUI-64 interface address either as a single 
	hexadecimal value or as hexadecimal byte values separated by 
	colon or hyphen (for example "01-23-45-67-89-AB-CD-EF").
	(See http://standards.ieee.org/regauth/oui/tutorials/EUI64.html
	for details about EUI-64).
      </xsd:documentation>
    </xsd:annotation>
    <xsd:restriction base="xsd:token">
      <xsd:pattern value="[0-9a-fA-F]{16}"/>
      <xsd:pattern value="[0-9a-fA-F]{2}([-:][0-9a-fA-F]{2}){7}"/>
    </xsd:restriction>
  </xsd:simpleType>


  <xsd:simpleType name="ipAddress">
    <xsd:annotation>
      <xsd:documentation>
	Defines an IP address of a single host in either hexadecimal 
	(for example "c0a80101") or dotted-decimal notation 
	(for example "192.168.1.1").
      </xsd:documentation>
    </xsd:annotation>
    <xsd:restriction base="xsd:token">
      <xsd:pattern value="[0-9a-fA-F]{8}"/>
      <xsd:pattern value="(0?\d?\d|[1]\d\d|2[0-5][0-5])(\.(0?\d?\d|[1]\d\d|2[0-5][0-5])){3}"/>
    </xsd:restriction>
  </xsd:simpleType>


  <xsd:simpleType name="ipv6Address">
    <xsd:annotation>
      <xsd:documentation>
	Defines an IPv6 address of a single host either as 128-bit 
	hexadecimal number or as one of the notations defined in 
	RFC 2373.
      </xsd:documentation>
    </xsd:annotation>
    <xsd:restriction base="xsd:token">
      <xsd:pattern value="[0-9a-fA-F]{32}">
	<xsd:annotation><xsd:documentation>
	    Matches a hexadecimal value. For example 
	    "108000000000000000088000200C417A"
	  </xsd:documentation></xsd:annotation>
      </xsd:pattern>
      <xsd:pattern value="[0-9a-fA-F]{1,4}(:[0-9a-fA-F]{1,4}){7}">
	<xsd:annotation><xsd:documentation>
	    Matches the syntax defined in RFC 2373, section 2.2.1
	    For example "1080:0:0:0:8:800:200C:417A"
	  </xsd:documentation></xsd:annotation>
      </xsd:pattern>
      <xsd:pattern value="([0-9a-fA-F]{1,4}(:[0-9a-fA-F]{1,4}){0,6})?::([0-9a-fA-F]{1,4}(:[0-9a-fA-F]{1,4}){0,6})?">
	<xsd:annotation><xsd:documentation>
	    Matches an address in compressed form as defined in 
	    RFC 2373, section 2.2.2.
	    For example "1080::8:800:200C:417A"
	  </xsd:documentation></xsd:annotation>
      </xsd:pattern>
      <xsd:pattern value="[0-9a-fA-F]{1,4}(:[0-9a-fA-F]{1,4}){5}:(0?\d?\d|[1]\d\d|2[0-5][0-5])(\.(0?\d?\d|[1]\d\d|2[0-5][0-5])){3}">
	<xsd:annotation><xsd:documentation>
	    Matches a mixed IPv6/IPv4 notation as defined in 
	    RFC 2373, section 2.2.3.
	    For example "1080:0:0:0:8:800:32.12.65.122"
	  </xsd:documentation></xsd:annotation>
      </xsd:pattern>
      <xsd:pattern value="([0-9a-fA-F]{1,4}(:[0-9a-fA-F]{1,4}){0,4})?::([0-9a-fA-F]{1,4}(:[0-9a-fA-F]{1,4}){0,4}):(0?\d?\d|[1]\d\d|2[0-5][0-5])(\.(0?\d?\d|[1]\d\d|2[0-5][0-5])){3}">
	<xsd:annotation><xsd:documentation>
	    Matches allowed combinations of sections 2.2.2 and 2.2.3
	    For example "1080::8:800:32.12.65.122"
	  </xsd:documentation></xsd:annotation>
      </xsd:pattern>
      <xsd:pattern value="([0-9a-fA-F]{1,4}(:[0-9a-fA-F]{1,4}){0,4})?::(0?\d?\d|[1]\d\d|2[0-5][0-5])(\.(0?\d?\d|[1]\d\d|2[0-5][0-5])){3}">
	<xsd:annotation><xsd:documentation>
	    Matches allowed combinations of sections 2.2.2 and 2.2.3
	    For example "1080::32.12.65.122"
	  </xsd:documentation></xsd:annotation>
      </xsd:pattern>
    </xsd:restriction>
  </xsd:simpleType>


  <xsd:simpleType name="fileURI">
    <xsd:annotation>
      <xsd:documentation>
	A URI scheme for file locations as defined in RFC 1738.
	Because xsd:anyURI already defines a general URI syntax 
	it is sufficient to restrict only the scheme prefix here.
      </xsd:documentation>
    </xsd:annotation>
    <xsd:restriction base="xsd:anyURI">
      <xsd:pattern value="file://.*"/>
    </xsd:restriction>
  </xsd:simpleType>


  <xsd:complexType name="checksumType">
    <xsd:annotation>
      <xsd:documentation>
	This datatype holds a checksum for a specified algorithm 
	(given as attribut value). The algorithm must be one of the 
	following list.
      </xsd:documentation>
    </xsd:annotation>
    <xsd:simpleContent>
      <xsd:extension base="hexNumber">
	<xsd:attribute name="type" use="required">
	  <xsd:simpleType>
	    <xsd:restriction base="xsd:token">
	      <xsd:enumeration value="SHA1"/>
	      <xsd:enumeration value="MD5"/>
	      <xsd:enumeration value="RIPEMD"/>
	      <xsd:enumeration value="HAVAL"/>
	      <xsd:enumeration value="SNEFRU"/>
	      <xsd:enumeration value="GOST"/>
	      <xsd:enumeration value="MD4"/>
	      <xsd:enumeration value="MD2"/>
	      <xsd:enumeration value="CRC32"/>
	      <xsd:enumeration value="CRC16"/>
	    </xsd:restriction>
	  </xsd:simpleType>
	</xsd:attribute>
      </xsd:extension>
    </xsd:simpleContent>
  </xsd:complexType>


  <xsd:simpleType name="mimeDatatype">
    <xsd:annotation>
      <xsd:documentation>
	The syntax of MIME content types is defined in RFC 2045, 
	section 5.1. As specified every token consists of one or more 
	ASCII characters with the exclusion of control characters, 
	SPACE, the characters ()@,;:\"/[]?= and &lt; and &gt;
	
	To avoid problems with unicode characters this restriction is
	expressed as an list of explicitly allowed characters here:
	0-9A-Z!#$%'*+-.^_`a-z{|}~ and &amp;
	
	The top level media types are restricted to the types defined
	in RFC 2045, section 5.1 and RFC 2046 including the "X-" 
	extension method): text, image, audio, video, application, 
	message, multipart
	ATTENTION: Top level media types defined according to the IETF
	registration process (described in RFC 2048) are NOT included 
	here and can't be described with this schema version.

	RFC 2045 allows media types to be appended with parameters 
	(separated by semicolon, for example: 
	"text/plain; charset=us-ascii")
	Parameters are not allowed here to keep things simple. 
	Instead there is an additional element for mime parameters,
	that may be used if parameters are considered important for
	the current task (see below for the "mimeParameterType").

	The regular expression is more complex, because RFC 2045 
	allows all uppercase/lowercase combinations for media types.
      </xsd:documentation>
    </xsd:annotation>
    <xsd:restriction base="xsd:token">
      <xsd:pattern value="[tT][eE][xX][tT]/[-0-9A-Za-z!#%'_`~\$\*\+\.\^\{\|\}&amp;]+"/>
      <xsd:pattern value="[iI][mM][aA][gG][eE]/[-0-9A-Za-z!#%'_`~\$\*\+\.\^\{\|\}&amp;]+"/>
      <xsd:pattern value="[aA][uU][dD][iI][oO]/[-0-9A-Za-z!#%'_`~\$\*\+\.\^\{\|\}&amp;]+"/>
      <xsd:pattern value="[vV][iI][dD][eE][oO]/[-0-9A-Za-z!#%'_`~\$\*\+\.\^\{\|\}&amp;]+"/>
      <xsd:pattern value="[aA][pP][pP][lL][iI][cC][aA][tT][iI][oO][nN]/[-0-9A-Za-z!#%'_`~\$\*\+\.\^\{\|\}&amp;]+"/>
      <xsd:pattern value="[mM][eE][sS][sS][aA][gG][eE]/[-0-9A-Za-z!#%'_`~\$\*\+\.\^\{\|\}&amp;]+"/>
      <xsd:pattern value="[mM][uU][lL][tT][iI][pP][aA][rR][tT]/[-0-9A-Za-z!#%'_`~\$\*\+\.\^\{\|\}&amp;]+"/>
      <xsd:pattern value="[Xx]-[-0-9A-Za-z!#%'_`~\$\*\+\.\^\{\|\}&amp;]+/[-0-9A-Za-z!#%'_`~\$\*\+\.\^\{\|\}&amp;]+"/>
    </xsd:restriction>
  </xsd:simpleType>


</xsd:schema>

