<?xml version="1.0" encoding="UTF-8"?>
<xsd:schema targetNamespace="http://www.cyclonecommerce.com/Schemas/2001/08/cop" xmlns="http://www.cyclonecommerce.com/Schemas/2001/08/cop" xmlns:ds="http://www.w3.org/2000/09/xmldsig#" xmlns:xsd="http://www.w3.org/2001/XMLSchema" elementFormDefault="qualified" attributeFormDefault="unqualified">
	<xsd:import namespace="http://www.w3.org/2000/09/xmldsig#" schemaLocation="http://www.w3.org/TR/xmldsig-core/xmldsig-core-schema.xsd"/>
	<xsd:annotation>
		<xsd:documentation>This schema represents organization details required for trading.</xsd:documentation>
	</xsd:annotation>
	<!--General definitions used within the rest of the schema.-->
	<xsd:element name="Comment">
		<xsd:annotation>
			<xsd:documentation>A freeform text field that can be used to provide descriptive information about an element.</xsd:documentation>
		</xsd:annotation>
		<xsd:complexType>
			<xsd:simpleContent>
				<xsd:extension base="xsd:string">
					<xsd:attribute name="lang" type="xsd:language" default="en"/>
				</xsd:extension>
			</xsd:simpleContent>
		</xsd:complexType>
	</xsd:element>
	<xsd:simpleType name="Identifier">
		<xsd:annotation>
			<xsd:documentation>An id for an element.  Can't use xsd:ID because it won't allow them to begin with a number.</xsd:documentation>
		</xsd:annotation>
		<xsd:restriction base="xsd:string"/>
	</xsd:simpleType>
	<xsd:simpleType name="IdentifierRef">
		<xsd:annotation>
			<xsd:documentation>A reference to an Identifier.</xsd:documentation>
		</xsd:annotation>
		<xsd:restriction base="Identifier"/>
	</xsd:simpleType>
	<xsd:simpleType name="OrganizationId">
		<xsd:annotation>
			<xsd:documentation>The server's unique internal identifier for an organization.</xsd:documentation>
		</xsd:annotation>
		<xsd:restriction base="Identifier">
			<xsd:minLength value="1"/>
		</xsd:restriction>
	</xsd:simpleType>
	<xsd:simpleType name="CommunityId">
		<xsd:annotation>
			<xsd:documentation>The server's unique internal identifier for a community.</xsd:documentation>
		</xsd:annotation>
		<xsd:restriction base="Identifier">
			<xsd:minLength value="1"/>
		</xsd:restriction>
	</xsd:simpleType>
	<xsd:element name="Community" nillable="true">
		<xsd:complexType>
			<xsd:sequence>
				<xsd:element name="CommunityName" type="xsd:string" minOccurs="0"/>
				<xsd:element name="BrokerId" type="OrganizationId" minOccurs="0"/>
			</xsd:sequence>
			<xsd:attribute name="communityId" type="CommunityId" use="required"/>
		</xsd:complexType>
	</xsd:element>
	<!--The following defines stuff for the Administrative Information-->
	<xsd:element name="OrganizationName">
		<xsd:annotation>
			<xsd:documentation>The name of the organization.</xsd:documentation>
		</xsd:annotation>
	</xsd:element>
	<xsd:element name="PersonName">
		<xsd:annotation>
			<xsd:documentation>The name of a person</xsd:documentation>
		</xsd:annotation>
		<xsd:complexType>
			<xsd:simpleContent>
				<xsd:extension base="xsd:string"/>
			</xsd:simpleContent>
		</xsd:complexType>
	</xsd:element>
	<xsd:complexType name="Phone" mixed="true">
		<xsd:annotation>
			<xsd:documentation>A phone number.</xsd:documentation>
		</xsd:annotation>
		<xsd:simpleContent>
			<xsd:extension base="xsd:string">
				<xsd:attribute name="type" type="xsd:string" use="optional"/>
			</xsd:extension>
		</xsd:simpleContent>
	</xsd:complexType>
	<xsd:simpleType name="Email">
		<xsd:annotation>
			<xsd:documentation>An email address.</xsd:documentation>
		</xsd:annotation>
		<xsd:restriction base="xsd:string"/>
	</xsd:simpleType>
	<xsd:element name="Contact">
		<xsd:annotation>
			<xsd:documentation>Information about a person.</xsd:documentation>
		</xsd:annotation>
		<xsd:complexType>
			<xsd:sequence>
				<xsd:element ref="Comment" minOccurs="0" maxOccurs="unbounded"/>
				<xsd:element ref="PersonName"/>
				<xsd:element name="Title" minOccurs="0"/>
				<xsd:element name="Department" minOccurs="0"/>
				<xsd:element name="Email" minOccurs="0" maxOccurs="unbounded">
					<xsd:annotation>
						<xsd:documentation>Email address.</xsd:documentation>
					</xsd:annotation>
					<xsd:complexType>
						<xsd:simpleContent>
							<xsd:extension base="Email">
								<xsd:attribute name="type" type="xsd:string" use="optional"/>
							</xsd:extension>
						</xsd:simpleContent>
					</xsd:complexType>
				</xsd:element>
				<xsd:element name="Phone" minOccurs="0" maxOccurs="unbounded">
					<xsd:complexType>
						<xsd:simpleContent>
							<xsd:extension base="Phone"/>
						</xsd:simpleContent>
					</xsd:complexType>
				</xsd:element>
				<xsd:element ref="PostalAddress" minOccurs="0"/>
			</xsd:sequence>
			<xsd:attribute name="contactId" type="Identifier" use="optional"/>
			<xsd:attribute name="type" type="xsd:string" use="optional"/>
		</xsd:complexType>
	</xsd:element>
	<xsd:element name="Contacts">
		<xsd:annotation>
			<xsd:documentation>Collection of Contact and ContactRefs.</xsd:documentation>
		</xsd:annotation>
		<xsd:complexType>
			<xsd:sequence>
				<xsd:element ref="Contact" minOccurs="0" maxOccurs="unbounded"/>
			</xsd:sequence>
		</xsd:complexType>
	</xsd:element>
	<xsd:element name="PostalAddress">
		<xsd:annotation>
			<xsd:documentation>Postal mailing address.</xsd:documentation>
		</xsd:annotation>
		<xsd:complexType>
			<xsd:sequence>
				<xsd:element ref="Comment" minOccurs="0" maxOccurs="unbounded"/>
				<xsd:element name="Street" type="xsd:string">
					<xsd:annotation>
						<xsd:documentation>The street address.  This may resolve to what may be interpreted as multiple lines.</xsd:documentation>
					</xsd:annotation>
				</xsd:element>
				<xsd:element name="City" type="xsd:string" minOccurs="0">
					<xsd:annotation>
						<xsd:documentation>City.</xsd:documentation>
					</xsd:annotation>
				</xsd:element>
				<xsd:element name="Stateprov" type="xsd:string" minOccurs="0">
					<xsd:annotation>
						<xsd:documentation>State or province depending on the country.</xsd:documentation>
					</xsd:annotation>
				</xsd:element>
				<xsd:element name="PostalCode" type="xsd:string">
					<xsd:annotation>
						<xsd:documentation>Postal or zip code.</xsd:documentation>
					</xsd:annotation>
				</xsd:element>
				<xsd:element name="Country" type="xsd:string" default="US">
					<xsd:annotation>
						<xsd:documentation>Country code.</xsd:documentation>
					</xsd:annotation>
				</xsd:element>
			</xsd:sequence>
		</xsd:complexType>
	</xsd:element>
	<xsd:simpleType name="RoutingIdType">
		<xsd:annotation>
			<xsd:documentation>The type of routing identifier, like DUNS, EDI, etc.</xsd:documentation>
		</xsd:annotation>
		<xsd:restriction base="xsd:string">
			<xsd:enumeration value="EDI"/>
			<xsd:enumeration value="EDIFACT"/>
			<xsd:enumeration value="DUNS"/>
		</xsd:restriction>
	</xsd:simpleType>
	<xsd:element name="RoutingId">
		<xsd:annotation>
			<xsd:documentation>An identifier such as DUNS or EDI used to uniquely identify a company for trading.</xsd:documentation>
		</xsd:annotation>
		<xsd:complexType>
			<xsd:simpleContent>
				<xsd:extension base="xsd:string">
					<xsd:attribute name="type" type="RoutingIdType" use="required"/>
				</xsd:extension>
			</xsd:simpleContent>
		</xsd:complexType>
	</xsd:element>
	<xsd:element name="Certificate">
		<xsd:annotation>
			<xsd:documentation>Information about a certificate. The initial version of each Interchange product only support the ds:KeyInfo/ds:X509Data section including ds:X509IssuerSerial and X509Certificate.  Any other elements used will be ignored, and if one of the two supported elements is not included the certificate will be considered invalid.</xsd:documentation>
		</xsd:annotation>
		<xsd:complexType>
			<xsd:sequence>
				<xsd:element ref="ds:KeyInfo"/>
			</xsd:sequence>
			<xsd:attribute name="certId" type="Identifier" use="required"/>
		</xsd:complexType>
	</xsd:element>
	<xsd:element name="CertificatetRef">
		<xsd:annotation>
			<xsd:documentation>A reference to a Certificate.</xsd:documentation>
		</xsd:annotation>
		<xsd:complexType>
			<xsd:attribute name="certId" type="IdentifierRef" use="required"/>
		</xsd:complexType>
	</xsd:element>
	<xsd:element name="Certificates">
		<xsd:annotation>
			<xsd:documentation>Collection of Certificates.</xsd:documentation>
		</xsd:annotation>
		<xsd:complexType>
			<xsd:sequence>
				<xsd:element ref="Certificate" minOccurs="0" maxOccurs="unbounded"/>
			</xsd:sequence>
			<xsd:attribute name="preferredEncryptionCertId" type="IdentifierRef" use="optional"/>
		</xsd:complexType>
	</xsd:element>
	<xsd:element name="AdministrativeInfo">
		<xsd:annotation>
			<xsd:documentation>Information describing an organization useful to humans.</xsd:documentation>
		</xsd:annotation>
		<xsd:complexType>
			<xsd:sequence>
				<xsd:element ref="OrganizationName"/>
				<xsd:element ref="PostalAddress" minOccurs="0"/>
				<xsd:element ref="Contacts" minOccurs="0"/>
			</xsd:sequence>
		</xsd:complexType>
	</xsd:element>
	<!--The following defines stuff for Transports-->
	<xsd:element name="Username" type="xsd:string">
		<xsd:annotation>
			<xsd:documentation>Username used to access a resource.</xsd:documentation>
		</xsd:annotation>
	</xsd:element>
	<xsd:element name="Password">
		<xsd:annotation>
			<xsd:documentation>Password used to access a secure resouce.</xsd:documentation>
		</xsd:annotation>
		<xsd:complexType>
			<xsd:simpleContent>
				<xsd:extension base="xsd:string">
					<xsd:attribute name="encrypted" type="xsd:boolean" use="required"/>
				</xsd:extension>
			</xsd:simpleContent>
		</xsd:complexType>
	</xsd:element>
	<xsd:simpleType name="IPAddress">
		<xsd:annotation>
			<xsd:documentation>Internet Protocal address, ex:  12.34.56.78</xsd:documentation>
		</xsd:annotation>
		<xsd:restriction base="xsd:string">
			<xsd:pattern value="(([0-1]?[0-9]?[0-9]|2[0-4][0-9]|25[0-9]){3}(.[0-1]?[0-9]?[0-9]|2[0-4][0-9]|25[0-5]))">
				<xsd:annotation>
					<xsd:documentation>This mess just restricts the value to standard IP addresses where each of four octets can have values 0-255.</xsd:documentation>
				</xsd:annotation>
			</xsd:pattern>
		</xsd:restriction>
	</xsd:simpleType>
	<xsd:simpleType name="DNSAddress">
		<xsd:annotation>
			<xsd:documentation>Domain Name Server address, ex: www.cyclonecommerce.com</xsd:documentation>
		</xsd:annotation>
		<xsd:restriction base="xsd:string"/>
	</xsd:simpleType>
	<xsd:simpleType name="SocketSecurityType">
		<xsd:annotation>
			<xsd:documentation>AUTHENTICATED or ANONYMOUS</xsd:documentation>
		</xsd:annotation>
		<xsd:restriction base="xsd:string">
			<xsd:enumeration value="AUTHENTICATED"/>
			<xsd:enumeration value="ANONYMOUS"/>
		</xsd:restriction>
	</xsd:simpleType>
	<xsd:element name="Host">
		<xsd:annotation>
			<xsd:documentation>A host address, either in DNS or IP, for a server.</xsd:documentation>
		</xsd:annotation>
		<xsd:simpleType>
			<xsd:union memberTypes="DNSAddress IPAddress"/>
		</xsd:simpleType>
	</xsd:element>
	<xsd:element name="Port">
		<xsd:annotation>
			<xsd:documentation>Socket port number.</xsd:documentation>
		</xsd:annotation>
		<xsd:simpleType>
			<xsd:restriction base="xsd:integer">
				<xsd:minInclusive value="1"/>
				<xsd:maxInclusive value="65000"/>
			</xsd:restriction>
		</xsd:simpleType>
	</xsd:element>
	<xsd:simpleType name="Directory">
		<xsd:annotation>
			<xsd:documentation>A directory on a file system or server such as FTP.</xsd:documentation>
		</xsd:annotation>
		<xsd:restriction base="xsd:string"/>
	</xsd:simpleType>
	<xsd:simpleType name="JMSConsumerType">
		<xsd:annotation>
			<xsd:documentation>For JMS, either a Queue or Topic.</xsd:documentation>
		</xsd:annotation>
		<xsd:restriction base="xsd:string">
			<xsd:enumeration value="QUEUE"/>
			<xsd:enumeration value="TOPIC"/>
		</xsd:restriction>
	</xsd:simpleType>
	<xsd:simpleType name="FirewallAuthenticationType">
		<xsd:annotation>
			<xsd:documentation>Either S/Key or ClearText</xsd:documentation>
		</xsd:annotation>
		<xsd:restriction base="xsd:string">
			<xsd:enumeration value="SKEY"/>
			<xsd:enumeration value="CLEARTEXT"/>
		</xsd:restriction>
	</xsd:simpleType>
	<xsd:element name="Firewall">
		<xsd:annotation>
			<xsd:documentation>Information about a transport server's firewall.</xsd:documentation>
		</xsd:annotation>
		<xsd:complexType>
			<xsd:sequence>
				<xsd:element ref="Host"/>
				<xsd:element ref="Port"/>
				<xsd:element name="Authentication" minOccurs="0">
					<xsd:annotation>
						<xsd:documentation>Optional S/Key or Clear text authentication.</xsd:documentation>
					</xsd:annotation>
					<xsd:complexType>
						<xsd:sequence>
							<xsd:element ref="Username"/>
							<xsd:element ref="Password"/>
						</xsd:sequence>
						<xsd:attribute name="type" type="FirewallAuthenticationType" use="required"/>
					</xsd:complexType>
				</xsd:element>
			</xsd:sequence>
		</xsd:complexType>
	</xsd:element>
	<xsd:element name="SocketSecurity">
		<xsd:annotation>
			<xsd:documentation>Type of SSL security.</xsd:documentation>
		</xsd:annotation>
		<xsd:complexType mixed="true">
			<xsd:sequence>
				<xsd:element ref="CertificatetRef" minOccurs="0"/>
			</xsd:sequence>
			<xsd:attribute name="type" type="SocketSecurityType" use="required"/>
		</xsd:complexType>
	</xsd:element>
	<xsd:complexType name="Transport">
		<xsd:annotation>
			<xsd:documentation>Base definition for a trading transport server.</xsd:documentation>
		</xsd:annotation>
		<xsd:sequence>
			<xsd:element ref="Comment" minOccurs="0" maxOccurs="unbounded"/>
			<xsd:element name="Schedules" minOccurs="0">
				<xsd:annotation>
					<xsd:documentation>Collection of schedules.</xsd:documentation>
				</xsd:annotation>
				<xsd:complexType>
					<xsd:sequence>
						<xsd:element name="schedule" minOccurs="0" maxOccurs="unbounded">
							<xsd:annotation>
								<xsd:documentation>Period of time including a start and stop time representing the period of time the transport is available.</xsd:documentation>
							</xsd:annotation>
							<xsd:complexType>
								<xsd:attribute name="startTime" type="xsd:time" use="required"/>
								<xsd:attribute name="stopTime" type="xsd:time" use="required"/>
							</xsd:complexType>
						</xsd:element>
					</xsd:sequence>
				</xsd:complexType>
			</xsd:element>
		</xsd:sequence>
		<xsd:attribute name="transportId" type="Identifier" use="optional"/>
	</xsd:complexType>
	<xsd:element name="TransportRef">
		<xsd:annotation>
			<xsd:documentation>A reference to a Transport defined elsewhere.</xsd:documentation>
		</xsd:annotation>
		<xsd:complexType>
			<xsd:attribute name="transportId" type="IdentifierRef" use="required"/>
		</xsd:complexType>
	</xsd:element>
	<xsd:element name="Transports">
		<xsd:annotation>
			<xsd:documentation>Collection of Transports defintions.</xsd:documentation>
		</xsd:annotation>
		<xsd:complexType>
			<xsd:sequence>
				<xsd:element ref="FileTransport" minOccurs="0" maxOccurs="unbounded"/>
				<xsd:element ref="FTPTransport" minOccurs="0" maxOccurs="unbounded"/>
				<xsd:element ref="HTTPTransport" minOccurs="0" maxOccurs="unbounded"/>
				<xsd:element ref="HTTPTransport_CI" minOccurs="0" maxOccurs="unbounded"/>
				<xsd:element ref="SMTPTransport" minOccurs="0" maxOccurs="unbounded"/>
				<xsd:element ref="SMTPTransport_CI" minOccurs="0" maxOccurs="unbounded"/>
				<xsd:element ref="JMSTransport" minOccurs="0" maxOccurs="unbounded"/>
				<xsd:element ref="MQSeriesTransport" minOccurs="0" maxOccurs="unbounded"/>
			</xsd:sequence>
			<xsd:attribute name="preferredTransportRef" type="IdentifierRef" use="optional"/>
		</xsd:complexType>
	</xsd:element>
	<xsd:element name="FileTransport">
		<xsd:annotation>
			<xsd:documentation>File system transport definition.</xsd:documentation>
		</xsd:annotation>
		<xsd:complexType>
			<xsd:complexContent>
				<xsd:extension base="Transport">
					<xsd:sequence>
						<xsd:element name="Directory">
							<xsd:annotation>
								<xsd:documentation>The directory on the file system.</xsd:documentation>
							</xsd:annotation>
							<xsd:complexType>
								<xsd:simpleContent>
									<xsd:extension base="Directory">
										<xsd:attribute name="isLocal" type="xsd:boolean"/>
									</xsd:extension>
								</xsd:simpleContent>
							</xsd:complexType>
						</xsd:element>
					</xsd:sequence>
				</xsd:extension>
			</xsd:complexContent>
		</xsd:complexType>
	</xsd:element>
	<xsd:element name="FTPTransport">
		<xsd:annotation>
			<xsd:documentation>File Transfer Protocol transport definition.</xsd:documentation>
		</xsd:annotation>
		<xsd:complexType>
			<xsd:complexContent>
				<xsd:extension base="Transport">
					<xsd:sequence>
						<xsd:element ref="Host"/>
						<xsd:element ref="Port"/>
						<xsd:element ref="Username"/>
						<xsd:element ref="Password"/>
						<xsd:element name="TempDir" type="Directory">
							<xsd:annotation>
								<xsd:documentation>Directory on the FTP server where incoming documents are temporarily stored as they are transferred.</xsd:documentation>
							</xsd:annotation>
						</xsd:element>
						<xsd:element name="PickupDir" type="Directory">
							<xsd:annotation>
								<xsd:documentation>Directory where the documents are moved after having been transferred to the TempDir.</xsd:documentation>
							</xsd:annotation>
						</xsd:element>
						<xsd:element name="TransferType" default="BINARY">
							<xsd:annotation>
								<xsd:documentation>BINARY or ASCII</xsd:documentation>
							</xsd:annotation>
							<xsd:simpleType>
								<xsd:restriction base="xsd:string">
									<xsd:enumeration value="ASCII"/>
									<xsd:enumeration value="BINARY"/>
								</xsd:restriction>
							</xsd:simpleType>
						</xsd:element>
						<xsd:element name="Mode" default="Passive">
							<xsd:annotation>
								<xsd:documentation>Port or Passive.  Passive means the FTP server selects the data port for the FTP data transfer. Port means the FTP client selects the data port for the FTP data transfer.</xsd:documentation>
							</xsd:annotation>
							<xsd:simpleType>
								<xsd:restriction base="xsd:string">
									<xsd:enumeration value="Port"/>
									<xsd:enumeration value="Passive"/>
								</xsd:restriction>
							</xsd:simpleType>
						</xsd:element>
						<xsd:element ref="Firewall" minOccurs="0"/>
						<xsd:element ref="SocketSecurity" minOccurs="0"/>
					</xsd:sequence>
				</xsd:extension>
			</xsd:complexContent>
		</xsd:complexType>
	</xsd:element>
	<xsd:element name="HTTPTransport">
		<xsd:annotation>
			<xsd:documentation>HyperText Transfer Protocol definition.</xsd:documentation>
		</xsd:annotation>
		<xsd:complexType>
			<xsd:complexContent>
				<xsd:extension base="Transport">
					<xsd:sequence>
						<xsd:element name="URL" type="xsd:anyURI"/>
						<xsd:element ref="Username" minOccurs="0"/>
						<xsd:element ref="Password" minOccurs="0"/>
						<xsd:element name="Method" default="POST">
							<xsd:annotation>
								<xsd:documentation>Either PUT or POST that the client should use to push docuemnts to the server.</xsd:documentation>
							</xsd:annotation>
							<xsd:simpleType>
								<xsd:restriction base="xsd:string">
									<xsd:enumeration value="PUT"/>
									<xsd:enumeration value="POST"/>
								</xsd:restriction>
							</xsd:simpleType>
						</xsd:element>
						<xsd:element name="DoubleMimeWrapped" type="xsd:boolean" default="false">
							<xsd:annotation>
								<xsd:documentation>Some servers will strip off MIME wrapping of a document requiring that the document be MIME wrapped twice.</xsd:documentation>
							</xsd:annotation>
						</xsd:element>
						<xsd:element ref="Firewall" minOccurs="0"/>
						<xsd:element ref="SocketSecurity" minOccurs="0"/>
					</xsd:sequence>
				</xsd:extension>
			</xsd:complexContent>
		</xsd:complexType>
	</xsd:element>
	<xsd:element name="HTTPTransport_CI">
		<xsd:annotation>
			<xsd:documentation>Cyclone Interchange Enterprise's specialized version of HTTP.</xsd:documentation>
		</xsd:annotation>
		<xsd:complexType>
			<xsd:complexContent>
				<xsd:extension base="Transport">
					<xsd:sequence>
						<xsd:element name="URL" type="xsd:anyURI"/>
						<xsd:element ref="Firewall" minOccurs="0"/>
						<xsd:element ref="SocketSecurity" minOccurs="0"/>
					</xsd:sequence>
				</xsd:extension>
			</xsd:complexContent>
		</xsd:complexType>
	</xsd:element>
	<xsd:element name="SMTPTransport">
		<xsd:annotation>
			<xsd:documentation>Simple Mail Transport Protocol transport definition.</xsd:documentation>
		</xsd:annotation>
		<xsd:complexType>
			<xsd:complexContent>
				<xsd:extension base="Transport">
					<xsd:sequence>
						<xsd:element ref="Host" minOccurs="0"/>
						<xsd:element ref="Port" minOccurs="0"/>
						<xsd:element ref="Username" minOccurs="0"/>
						<xsd:element ref="Password" minOccurs="0"/>
						<xsd:element name="Recipient" type="Email">
							<xsd:annotation>
								<xsd:documentation>Email address of the recipient.</xsd:documentation>
							</xsd:annotation>
						</xsd:element>
						<xsd:element name="IsCompliant" type="xsd:boolean" default="true">
							<xsd:annotation>
								<xsd:documentation>Set to false for SMTP implementations that do not leave the MIME wrapping in tact.</xsd:documentation>
							</xsd:annotation>
						</xsd:element>
						<xsd:element ref="Firewall" minOccurs="0"/>
						<xsd:element ref="SocketSecurity" minOccurs="0"/>
					</xsd:sequence>
				</xsd:extension>
			</xsd:complexContent>
		</xsd:complexType>
	</xsd:element>
	<xsd:element name="SMTPTransport_CI">
		<xsd:annotation>
			<xsd:documentation>Cyclone Interchange Enterprise's specialized version of SMTP.</xsd:documentation>
		</xsd:annotation>
		<xsd:complexType>
			<xsd:complexContent>
				<xsd:extension base="Transport">
					<xsd:sequence>
						<xsd:element ref="Host" minOccurs="0"/>
						<xsd:element ref="Port" minOccurs="0"/>
						<xsd:element name="Recipient" type="Email">
							<xsd:annotation>
								<xsd:documentation>Email address of the recipient.</xsd:documentation>
							</xsd:annotation>
						</xsd:element>
						<xsd:element ref="Firewall" minOccurs="0"/>
						<xsd:element ref="SocketSecurity" minOccurs="0"/>
					</xsd:sequence>
				</xsd:extension>
			</xsd:complexContent>
		</xsd:complexType>
	</xsd:element>
	<xsd:element name="JMSTransport">
		<xsd:annotation>
			<xsd:documentation>Java Message Service (JMS) transport definition.</xsd:documentation>
		</xsd:annotation>
		<xsd:complexType>
			<xsd:complexContent>
				<xsd:extension base="Transport">
					<xsd:sequence>
						<xsd:element ref="Username" minOccurs="0"/>
						<xsd:element ref="Password" minOccurs="0"/>
						<xsd:element name="ConnectionFactory" type="xsd:string">
							<xsd:annotation>
								<xsd:documentation>The name of the connection factory.</xsd:documentation>
							</xsd:annotation>
						</xsd:element>
						<xsd:element name="Consumer">
							<xsd:annotation>
								<xsd:documentation>The name of the Queue or Topic.</xsd:documentation>
							</xsd:annotation>
							<xsd:complexType>
								<xsd:simpleContent>
									<xsd:extension base="xsd:string">
										<xsd:attribute name="type" type="JMSConsumerType" default="QUEUE"/>
									</xsd:extension>
								</xsd:simpleContent>
							</xsd:complexType>
						</xsd:element>
						<xsd:element name="JNDI">
							<xsd:annotation>
								<xsd:documentation>Java Naming and Directory Interface defintion to locate the JMS provider.</xsd:documentation>
							</xsd:annotation>
							<xsd:complexType>
								<xsd:sequence>
									<xsd:element name="Location" type="xsd:anyURI">
										<xsd:annotation>
											<xsd:documentation>The URI location of the JMS server.</xsd:documentation>
										</xsd:annotation>
									</xsd:element>
									<xsd:element ref="Username" minOccurs="0"/>
									<xsd:element ref="Password" minOccurs="0"/>
									<xsd:element name="ContextFactory" type="xsd:string">
										<xsd:annotation>
											<xsd:documentation>The name of the JNDI context factory.</xsd:documentation>
										</xsd:annotation>
									</xsd:element>
								</xsd:sequence>
							</xsd:complexType>
						</xsd:element>
					</xsd:sequence>
				</xsd:extension>
			</xsd:complexContent>
		</xsd:complexType>
	</xsd:element>
	<xsd:element name="MQSeriesTransport">
		<xsd:annotation>
			<xsd:documentation>IBM's MQ Series</xsd:documentation>
		</xsd:annotation>
		<xsd:complexType>
			<xsd:complexContent>
				<xsd:extension base="Transport">
					<xsd:sequence>
						<xsd:element ref="Host"/>
						<xsd:element ref="Port"/>
						<xsd:element ref="Username" minOccurs="0"/>
						<xsd:element ref="Password" minOccurs="0"/>
						<xsd:element name="QueueManager" type="xsd:string"/>
						<xsd:element name="Queue" type="xsd:string"/>
						<xsd:element name="Channel" type="xsd:string"/>
					</xsd:sequence>
				</xsd:extension>
			</xsd:complexContent>
		</xsd:complexType>
	</xsd:element>
	<!--The following defines business protocol information -->
	<xsd:complexType name="BusinessProtocol">
		<xsd:annotation>
			<xsd:documentation>Base definition for a business protocol.</xsd:documentation>
		</xsd:annotation>
		<xsd:sequence>
			<xsd:element ref="TransportRef" maxOccurs="unbounded"/>
		</xsd:sequence>
		<xsd:attribute name="businessProtocolId" type="Identifier" use="required"/>
	</xsd:complexType>
	<xsd:element name="BusinessProtocolRef">
		<xsd:annotation>
			<xsd:documentation>A reference to a business protocol definition.</xsd:documentation>
		</xsd:annotation>
		<xsd:complexType>
			<xsd:attribute name="businessProtocolId" type="IdentifierRef" use="required"/>
		</xsd:complexType>
	</xsd:element>
	<xsd:element name="BusinessProtocols">
		<xsd:annotation>
			<xsd:documentation>Collection of Business protocol definitions.</xsd:documentation>
		</xsd:annotation>
		<xsd:complexType>
			<xsd:all>
				<xsd:element name="AS1Protocol" type="BusinessProtocol" minOccurs="0"/>
				<xsd:element name="AS2Protocol" type="BusinessProtocol" minOccurs="0"/>
				<xsd:element name="RosettaNetProtocol" type="BusinessProtocol" minOccurs="0"/>
				<xsd:element name="ebXMLProtocol" type="BusinessProtocol" minOccurs="0"/>
			</xsd:all>
		</xsd:complexType>
	</xsd:element>
	<!--The following defines the top-level OrganizationData-->
	<xsd:element name="OrganizationProfile">
		<xsd:annotation>
			<xsd:documentation>All information needed to trade with an organization.</xsd:documentation>
		</xsd:annotation>
		<xsd:complexType>
			<xsd:sequence>
				<xsd:element ref="Comment" minOccurs="0" maxOccurs="unbounded"/>
				<xsd:element ref="AdministrativeInfo" minOccurs="0"/>
				<xsd:element name="RoutingIds" minOccurs="0">
					<xsd:annotation>
						<xsd:documentation>Collection of RoutingIds</xsd:documentation>
					</xsd:annotation>
					<xsd:complexType>
						<xsd:sequence>
							<xsd:element ref="RoutingId" minOccurs="0" maxOccurs="unbounded"/>
						</xsd:sequence>
					</xsd:complexType>
				</xsd:element>
				<xsd:element name="BrokerId" type="OrganizationId" minOccurs="0">
					<xsd:annotation>
						<xsd:documentation>Within this community, this organization trades through a broker (hub). This references another profile with this id.</xsd:documentation>
					</xsd:annotation>
				</xsd:element>
				<xsd:element name="Communities" minOccurs="0">
					<xsd:annotation>
						<xsd:documentation>Collection of communities the trading profile is actively a member of.</xsd:documentation>
					</xsd:annotation>
					<xsd:complexType>
						<xsd:sequence>
							<xsd:element ref="Community" minOccurs="0" maxOccurs="unbounded"/>
						</xsd:sequence>
					</xsd:complexType>
				</xsd:element>
				<xsd:element ref="Transports" minOccurs="0"/>
				<xsd:element ref="Certificates" minOccurs="0"/>
				<xsd:element ref="BusinessProtocols" minOccurs="0"/>
			</xsd:sequence>
			<xsd:attribute name="id" type="OrganizationId" use="optional">
				<xsd:annotation>
					<xsd:documentation>The OrganizationId exists for valid profiles existing within the server.  If a client is sending a profile for an organization that is not already in the server's repository, this id will not be present as the server will be assigning one for it.</xsd:documentation>
				</xsd:annotation>
			</xsd:attribute>
		</xsd:complexType>
	</xsd:element>
</xsd:schema>
