<?xml version="1.0" encoding="utf-8"?>
<wsdl:definitions xmlns:http="http://schemas.xmlsoap.org/wsdl/http/" xmlns:n0="http://sap.com/xi/SRM/Basis/Global"
	xmlns:soap="http://schemas.xmlsoap.org/wsdl/soap/" xmlns:tns="http://www.example.org" xmlns:tested="http://www.example.org"
	xmlns:wsdl="http://schemas.xmlsoap.org/wsdl/" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns="">
	<wsdl:types>
		<xsd:schema xmlns="" xmlns:xi1="http://sap.com/xi/SRM/Basis/Global"
			xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:tns="http://www.example.org" xmlns:tested="http://www.example.org">
			<xsd:element name="PurchaseOrderConfirmationRequest"
				type="PurchaseOrderMessage" />
			<xsd:element name="PurchaseOrderConfirmationRequestResponse"
				type="BusinessTransactionDocumentID" />
			<xsd:simpleType name="AcceptanceStatusCode">
				<xsd:restriction base="xsd:token">
					<xsd:length value="2" />
				</xsd:restriction>
			</xsd:simpleType>
			<xsd:simpleType name="ActionCode">
				<xsd:restriction base="xsd:token">
					<xsd:length value="2" />
				</xsd:restriction>
			</xsd:simpleType>
			<xsd:complexType name="Address">
				<xsd:sequence>
					<xsd:element name="OrganisationFormattedName"
						minOccurs="0" maxOccurs="unbounded" />
					<xsd:element name="PersonName" minOccurs="0" type="PersonName" />
					<xsd:element name="FunctionalTitleName" minOccurs="0">
						<xsd:simpleType>
							<xsd:restriction base="xsd:string">
								<xsd:maxLength value="40" />
							</xsd:restriction>
						</xsd:simpleType>
					</xsd:element>
					<xsd:element name="DepartmentName" minOccurs="0">
						<xsd:simpleType>
							<xsd:restriction base="xsd:string">
								<xsd:maxLength value="40" />
							</xsd:restriction>
						</xsd:simpleType>
					</xsd:element>
					<xsd:element name="Office" minOccurs="0">
						<xsd:complexType>
							<xsd:sequence>
								<xsd:element name="BuildingID" minOccurs="0">
									<xsd:simpleType>
										<xsd:restriction base="xsd:string">
											<xsd:maxLength value="10" />
										</xsd:restriction>
									</xsd:simpleType>
								</xsd:element>
								<xsd:element name="FloorID" minOccurs="0">
									<xsd:simpleType>
										<xsd:restriction base="xsd:string">
											<xsd:maxLength value="10" />
										</xsd:restriction>
									</xsd:simpleType>
								</xsd:element>
								<xsd:element name="RoomID" minOccurs="0">
									<xsd:simpleType>
										<xsd:restriction base="xsd:string">
											<xsd:maxLength value="10" />
										</xsd:restriction>
									</xsd:simpleType>
								</xsd:element>
								<xsd:element name="InhouseMailID" minOccurs="0">
									<xsd:simpleType>
										<xsd:restriction base="xsd:string">
											<xsd:maxLength value="10" />
										</xsd:restriction>
									</xsd:simpleType>
								</xsd:element>
								<xsd:element name="CorrespondenceShortName"
									minOccurs="0">
									<xsd:simpleType>
										<xsd:restriction base="xsd:string">
											<xsd:maxLength value="10" />
										</xsd:restriction>
									</xsd:simpleType>
								</xsd:element>
							</xsd:sequence>
						</xsd:complexType>
					</xsd:element>
					<xsd:element name="PhysicalAddress" minOccurs="0">
						<xsd:complexType>
							<xsd:sequence>
								<xsd:element name="CountryCode" minOccurs="0"
									type="CountryCode" />
								<xsd:element name="RegionCode" minOccurs="0"
									type="RegionCode" />
								<xsd:element name="StreetPostalCode" minOccurs="0">
									<xsd:simpleType>
										<xsd:restriction base="xsd:token">
											<xsd:maxLength value="10" />
										</xsd:restriction>
									</xsd:simpleType>
								</xsd:element>
								<xsd:element name="POBoxPostalCode" minOccurs="0">
									<xsd:simpleType>
										<xsd:restriction base="xsd:token">
											<xsd:maxLength value="10" />
										</xsd:restriction>
									</xsd:simpleType>
								</xsd:element>
								<xsd:element name="CompanyPostalCode" minOccurs="0">
									<xsd:simpleType>
										<xsd:restriction base="xsd:token">
											<xsd:maxLength value="10" />
										</xsd:restriction>
									</xsd:simpleType>
								</xsd:element>
								<xsd:element name="CityName" minOccurs="0">
									<xsd:simpleType>
										<xsd:restriction base="xsd:string">
											<xsd:maxLength value="40" />
										</xsd:restriction>
									</xsd:simpleType>
								</xsd:element>
								<xsd:element name="AdditionalCityName" minOccurs="0">
									<xsd:simpleType>
										<xsd:restriction base="xsd:string">
											<xsd:maxLength value="40" />
										</xsd:restriction>
									</xsd:simpleType>
								</xsd:element>
								<xsd:element name="DistrictName" minOccurs="0">
									<xsd:simpleType>
										<xsd:restriction base="xsd:string">
											<xsd:maxLength value="40" />
										</xsd:restriction>
									</xsd:simpleType>
								</xsd:element>
								<xsd:element name="POBoxID" minOccurs="0">
									<xsd:simpleType>
										<xsd:restriction base="xsd:string">
											<xsd:maxLength value="10" />
										</xsd:restriction>
									</xsd:simpleType>
								</xsd:element>
								<xsd:element name="POBoxIndicator" minOccurs="0"
									type="xsd:boolean" />
								<xsd:element name="POBoxCountryCode" minOccurs="0"
									type="CountryCode" />
								<xsd:element name="POBoxRegionCode" minOccurs="0"
									type="RegionCode" />
								<xsd:element name="POBoxCityName" minOccurs="0">
									<xsd:simpleType>
										<xsd:restriction base="xsd:string">
											<xsd:maxLength value="40" />
										</xsd:restriction>
									</xsd:simpleType>
								</xsd:element>
								<xsd:element name="StreetName" minOccurs="0">
									<xsd:simpleType>
										<xsd:restriction base="xsd:string">
											<xsd:maxLength value="60" />
										</xsd:restriction>
									</xsd:simpleType>
								</xsd:element>
								<xsd:element name="StreetPrefixName" minOccurs="0"
									maxOccurs="unbounded" />
								<xsd:element name="StreetSuffixName" minOccurs="0"
									maxOccurs="unbounded" />
								<xsd:element name="HouseID" minOccurs="0">
									<xsd:simpleType>
										<xsd:restriction base="xsd:string">
											<xsd:maxLength value="10" />
										</xsd:restriction>
									</xsd:simpleType>
								</xsd:element>
								<xsd:element name="AdditionalHouseID" minOccurs="0">
									<xsd:simpleType>
										<xsd:restriction base="xsd:string">
											<xsd:maxLength value="10" />
										</xsd:restriction>
									</xsd:simpleType>
								</xsd:element>
								<xsd:element name="BuildingID" minOccurs="0">
									<xsd:simpleType>
										<xsd:restriction base="xsd:string">
											<xsd:maxLength value="20" />
										</xsd:restriction>
									</xsd:simpleType>
								</xsd:element>
								<xsd:element name="FloorID" minOccurs="0">
									<xsd:simpleType>
										<xsd:restriction base="xsd:string">
											<xsd:maxLength value="10" />
										</xsd:restriction>
									</xsd:simpleType>
								</xsd:element>
								<xsd:element name="RoomID" minOccurs="0">
									<xsd:simpleType>
										<xsd:restriction base="xsd:string">
											<xsd:maxLength value="10" />
										</xsd:restriction>
									</xsd:simpleType>
								</xsd:element>
								<xsd:element name="CareOfName" minOccurs="0">
									<xsd:simpleType>
										<xsd:restriction base="xsd:string">
											<xsd:maxLength value="40" />
										</xsd:restriction>
									</xsd:simpleType>
								</xsd:element>
								<xsd:element name="Description" minOccurs="0"
									maxOccurs="unbounded" type="Description" />
							</xsd:sequence>
						</xsd:complexType>
					</xsd:element>
					<xsd:element name="TaxJurisdictionCode" minOccurs="0"
						type="TaxJurisdictionCode" />
					<xsd:element name="TimeZoneDifferenceValue" minOccurs="0"
						type="TimeZoneDifferenceValue" />
					<xsd:element name="GeoCoordinates" minOccurs="0"
						type="GeoCoordinates" />
					<xsd:element name="Communication" minOccurs="0">
						<xsd:complexType>
							<xsd:sequence>
								<xsd:element name="CorrespondenceLanguageCode"
									minOccurs="0" type="LanguageCode" />
								<xsd:element name="Telephone" minOccurs="0"
									maxOccurs="unbounded">
									<xsd:complexType>
										<xsd:sequence>
											<xsd:element name="Number" type="PhoneNumber" />
											<xsd:element name="NumberDefaultIndicator" type="xsd:boolean" />
											<xsd:element name="NumberDescription" minOccurs="0"
												maxOccurs="unbounded" type="Description" />
											<xsd:element name="NumberUsageDenialIndicator"
												type="xsd:boolean" />
										</xsd:sequence>
									</xsd:complexType>
								</xsd:element>
								<xsd:element name="MobilePhone" minOccurs="0"
									maxOccurs="unbounded">
									<xsd:complexType>
										<xsd:sequence>
											<xsd:element name="Number" type="PhoneNumber" />
											<xsd:element name="NumberDefaultIndicator" type="xsd:boolean" />
											<xsd:element name="NumberDescription" minOccurs="0"
												maxOccurs="unbounded" type="Description" />
											<xsd:element name="NumberUsageDenialIndicator"
												type="xsd:boolean" />
										</xsd:sequence>
									</xsd:complexType>
								</xsd:element>
								<xsd:element name="Facsimile" minOccurs="0"
									maxOccurs="unbounded">
									<xsd:complexType>
										<xsd:sequence>
											<xsd:element name="Number" type="PhoneNumber" />
											<xsd:element name="NumberDefaultIndicator" type="xsd:boolean" />
											<xsd:element name="NumberDescription" minOccurs="0"
												maxOccurs="unbounded" type="Description" />
											<xsd:element name="NumberUsageDenialIndicator"
												type="xsd:boolean" />
										</xsd:sequence>
									</xsd:complexType>
								</xsd:element>
								<xsd:element name="Email" minOccurs="0" maxOccurs="unbounded">
									<xsd:complexType>
										<xsd:sequence>
											<xsd:element name="Address" type="EmailAddress" />
											<xsd:element name="AddressDefaultIndicator" type="xsd:boolean" />
											<xsd:element name="AddressDescription" minOccurs="0"
												maxOccurs="unbounded" type="Description" />
											<xsd:element name="AddressUsageDenialIndicator"
												type="xsd:boolean" />
										</xsd:sequence>
									</xsd:complexType>
								</xsd:element>
								<xsd:element name="Web" minOccurs="0" maxOccurs="unbounded">
									<xsd:complexType>
										<xsd:sequence>
											<xsd:element name="Address" type="WebAddress" />
											<xsd:element name="AddressDefaultIndicator" type="xsd:boolean" />
											<xsd:element name="AddressDescription" minOccurs="0"
												maxOccurs="unbounded" type="Description" />
										</xsd:sequence>
									</xsd:complexType>
								</xsd:element>
							</xsd:sequence>
						</xsd:complexType>
					</xsd:element>
				</xsd:sequence>
			</xsd:complexType>
			<xsd:complexType name="Amount">
				<xsd:simpleContent>
					<xsd:extension base="AmountContent">
						<xsd:attribute name="currencyCode" type="xsd:token"
							use="required" />
					</xsd:extension>
				</xsd:simpleContent>
			</xsd:complexType>
			<xsd:simpleType name="AmountContent">
				<xsd:restriction base="xsd:decimal">
					<xsd:totalDigits value="28" />
					<xsd:fractionDigits value="6" />
				</xsd:restriction>
			</xsd:simpleType>
			<xsd:complexType name="Attachment">
				<xsd:simpleContent>
					<xsd:extension base="xsd:normalizedString">
						<xsd:attribute name="id" type="xsd:string" use="required" />
						<xsd:attribute name="filename" type="xsd:string" />
					</xsd:extension>
				</xsd:simpleContent>
			</xsd:complexType>
			<xsd:simpleType name="AttachmentWebAddress">
				<xsd:restriction base="xsd:anyURI">
					<xsd:maxLength value="255" />
				</xsd:restriction>
			</xsd:simpleType>
			<xsd:complexType name="BusinessDocumentMessageHeader">
				<xsd:sequence>
					<xsd:element name="ID" type="BusinessDocumentMessageID" />
					<xsd:element name="ReferenceID" minOccurs="0"
						type="BusinessDocumentMessageID" />
					<xsd:element name="CreationDateTime" type="DateTime" />
					<xsd:element name="SenderParty" minOccurs="0"
						type="BusinessDocumentMessageHeaderParty" />
					<xsd:element name="RecipientParty" minOccurs="0"
						maxOccurs="unbounded" type="BusinessDocumentMessageHeaderParty" />
				</xsd:sequence>
			</xsd:complexType>
			<xsd:complexType name="BusinessDocumentMessageHeaderParty">
				<xsd:sequence>
					<xsd:element name="InternalID" minOccurs="0"
						type="PartyInternalID" />
					<xsd:element name="StandardID" minOccurs="0" maxOccurs="unbounded"
						type="PartyStandardID" />
					<xsd:element name="ContactPerson" minOccurs="0"
						type="BusinessDocumentMessageHeaderPartyContactPerson" />
				</xsd:sequence>
			</xsd:complexType>
			<xsd:complexType name="BusinessDocumentMessageHeaderPartyContactPerson">
				<xsd:sequence>
					<xsd:element name="Address" minOccurs="0" type="Address" />
				</xsd:sequence>
			</xsd:complexType>
			<xsd:complexType name="BusinessDocumentMessageID">
				<xsd:simpleContent>
					<xsd:extension base="BusinessDocumentMessageIDContent">
						<xsd:attribute name="schemeID" type="xsd:token" />
						<xsd:attribute name="schemeAgencyID" type="xsd:token" />
						<xsd:attribute name="schemeAgencySchemeAgencyID"
							type="xsd:token" />
					</xsd:extension>
				</xsd:simpleContent>
			</xsd:complexType>
			<xsd:simpleType name="BusinessDocumentMessageIDContent">
				<xsd:restriction base="xsd:string">
					<xsd:maxLength value="35" />
				</xsd:restriction>
			</xsd:simpleType>
			<xsd:complexType name="BusinessTransactionDocumentID">
				<xsd:simpleContent>
					<xsd:extension base="BusinessTransactionDocumentIDContent">
						<xsd:attribute name="schemeID" type="xsd:token" />
						<xsd:attribute name="schemeAgencyID" type="xsd:token" />
						<xsd:attribute name="schemeAgencySchemeID" type="xsd:token" />
						<xsd:attribute name="schemeAgencySchemeAgencyID"
							type="xsd:token" />
					</xsd:extension>
				</xsd:simpleContent>
			</xsd:complexType>
			<xsd:simpleType name="BusinessTransactionDocumentIDContent">
				<xsd:restriction base="xsd:token">
					<xsd:maxLength value="35" />
				</xsd:restriction>
			</xsd:simpleType>
			<xsd:simpleType
				name="BusinessTransactionDocumentItemHierarchyRelationshipTypeCode">
				<xsd:restriction base="xsd:token">
					<xsd:length value="3" />
				</xsd:restriction>
			</xsd:simpleType>
			<xsd:simpleType name="BusinessTransactionDocumentItemID">
				<xsd:restriction base="xsd:token">
					<xsd:maxLength value="10" />
				</xsd:restriction>
			</xsd:simpleType>
			<xsd:simpleType name="BusinessTransactionDocumentItemScheduleLineID">
				<xsd:restriction base="xsd:token">
					<xsd:maxLength value="4" />
				</xsd:restriction>
			</xsd:simpleType>
			<xsd:complexType name="BusinessTransactionDocumentLocation">
				<xsd:sequence>
					<xsd:element name="InternalID" minOccurs="0"
						type="LocationInternalID" />
					<xsd:element name="StandardID" minOccurs="0" maxOccurs="unbounded"
						type="LocationStandardID" />
					<xsd:element name="BuyerID" minOccurs="0" type="LocationPartyID" />
					<xsd:element name="SellerID" minOccurs="0"
						type="LocationPartyID" />
					<xsd:element name="ProductRecipientID" minOccurs="0"
						type="LocationPartyID" />
					<xsd:element name="VendorID" minOccurs="0"
						type="LocationPartyID" />
					<xsd:element name="BillToID" minOccurs="0"
						type="LocationPartyID" />
					<xsd:element name="BillFromID" minOccurs="0"
						type="LocationPartyID" />
					<xsd:element name="BidderID" minOccurs="0"
						type="LocationPartyID" />
					<xsd:element name="Address" minOccurs="0" type="Address" />
					<xsd:element name="Note" minOccurs="0" type="Note" />
				</xsd:sequence>
			</xsd:complexType>
			<xsd:complexType name="BusinessTransactionDocumentParty">
				<xsd:sequence>
					<xsd:element name="InternalID" minOccurs="0"
						type="PartyInternalID" />
					<xsd:element name="StandardID" minOccurs="0" maxOccurs="unbounded"
						type="PartyStandardID" />
					<xsd:element name="BuyerID" minOccurs="0" type="PartyPartyID" />
					<xsd:element name="SellerID" minOccurs="0" type="PartyPartyID" />
					<xsd:element name="ProductRecipientID" minOccurs="0"
						type="PartyPartyID" />
					<xsd:element name="VendorID" minOccurs="0" type="PartyPartyID" />
					<xsd:element name="BillToID" minOccurs="0" type="PartyPartyID" />
					<xsd:element name="BillFromID" minOccurs="0" type="PartyPartyID" />
					<xsd:element name="BidderID" minOccurs="0" type="PartyPartyID" />
					<xsd:element name="TaxID" minOccurs="0" type="PartyTaxID" />
					<xsd:element name="Address" minOccurs="0" type="Address" />
					<xsd:element name="ContactPerson" minOccurs="0"
						type="ContactPerson" />
				</xsd:sequence>
			</xsd:complexType>
			<xsd:complexType name="BusinessTransactionDocumentProduct">
				<xsd:sequence>
					<xsd:element name="InternalID" minOccurs="0"
						type="ProductInternalID" />
					<xsd:element name="StandardID" minOccurs="0" maxOccurs="unbounded"
						type="ProductStandardID" />
					<xsd:element name="BuyerID" minOccurs="0" type="ProductPartyID" />
					<xsd:element name="SellerID" minOccurs="0" type="ProductPartyID" />
					<xsd:element name="ProductRecipientID" minOccurs="0"
						type="ProductPartyID" />
					<xsd:element name="VendorID" minOccurs="0" type="ProductPartyID" />
					<xsd:element name="ManufacturerID" minOccurs="0"
						type="ProductPartyID" />
					<xsd:element name="BillToID" minOccurs="0" type="ProductPartyID" />
					<xsd:element name="BillFromID" minOccurs="0"
						type="ProductPartyID" />
					<xsd:element name="BidderID" minOccurs="0" type="ProductPartyID" />
					<xsd:element name="TypeCode" minOccurs="0"
						type="ProductTypeCode" />
					<xsd:element name="Note" minOccurs="0" type="Note" />
				</xsd:sequence>
			</xsd:complexType>
			<xsd:complexType name="BusinessTransactionDocumentProductCategory">
				<xsd:sequence>
					<xsd:element name="InternalID" minOccurs="0"
						type="ProductCategoryInternalID" />
					<xsd:element name="StandardID" minOccurs="0" maxOccurs="unbounded"
						type="ProductCategoryStandardID" />
					<xsd:element name="BuyerID" minOccurs="0"
						type="ProductCategoryPartyID" />
					<xsd:element name="SellerID" minOccurs="0"
						type="ProductCategoryPartyID" />
					<xsd:element name="ProductRecipientID" minOccurs="0"
						type="ProductCategoryPartyID" />
					<xsd:element name="VendorID" minOccurs="0"
						type="ProductCategoryPartyID" />
					<xsd:element name="ManufacturerID" minOccurs="0"
						type="ProductCategoryPartyID" />
					<xsd:element name="BillToID" minOccurs="0"
						type="ProductCategoryPartyID" />
					<xsd:element name="BillFromID" minOccurs="0"
						type="ProductCategoryPartyID" />
					<xsd:element name="BidderID" minOccurs="0"
						type="ProductCategoryPartyID" />
				</xsd:sequence>
			</xsd:complexType>
			<xsd:complexType name="BusinessTransactionDocumentReference">
				<xsd:sequence>
					<xsd:element name="ID" type="BusinessTransactionDocumentID" />
					<xsd:element name="ItemID" minOccurs="0" maxOccurs="unbounded"
						type="BusinessTransactionDocumentItemID" />
				</xsd:sequence>
			</xsd:complexType>
			<xsd:complexType name="BusinessTransactionDocumentShipFromLocation">
				<xsd:sequence>
					<xsd:element name="InternalID" minOccurs="0"
						type="LocationInternalID" />
					<xsd:element name="StandardID" minOccurs="0" maxOccurs="unbounded"
						type="LocationStandardID" />
					<xsd:element name="BuyerID" minOccurs="0" type="LocationPartyID" />
					<xsd:element name="SellerID" minOccurs="0"
						type="LocationPartyID" />
					<xsd:element name="ProductRecipientID" minOccurs="0"
						type="LocationPartyID" />
					<xsd:element name="VendorID" minOccurs="0"
						type="LocationPartyID" />
					<xsd:element name="Address" minOccurs="0" type="Address" />
					<xsd:element name="Note" minOccurs="0" type="Note" />
					<xsd:element name="LoadingLocation" minOccurs="0"
						type="BusinessTransactionDocumentLocation" />
				</xsd:sequence>
			</xsd:complexType>
			<xsd:complexType name="BusinessTransactionDocumentShipToLocation">
				<xsd:sequence>
					<xsd:element name="InternalID" minOccurs="0"
						type="LocationInternalID" />
					<xsd:element name="StandardID" minOccurs="0" maxOccurs="unbounded"
						type="LocationStandardID" />
					<xsd:element name="BuyerID" minOccurs="0" type="LocationPartyID" />
					<xsd:element name="SellerID" minOccurs="0"
						type="LocationPartyID" />
					<xsd:element name="ProductRecipientID" minOccurs="0"
						type="LocationPartyID" />
					<xsd:element name="VendorID" minOccurs="0"
						type="LocationPartyID" />
					<xsd:element name="Address" minOccurs="0" type="Address" />
					<xsd:element name="Note" minOccurs="0" type="Note" />
					<xsd:element name="UnloadingLocation" minOccurs="0"
						type="BusinessTransactionDocumentLocation" />
				</xsd:sequence>
			</xsd:complexType>
			<xsd:simpleType name="CancelledIndicator">
				<xsd:restriction base="xsd:boolean" />
			</xsd:simpleType>
			<xsd:complexType name="CashDiscount">
				<xsd:sequence>
					<xsd:element name="DaysValue">
						<xsd:simpleType>
							<xsd:restriction base="xsd:integer">
								<xsd:totalDigits value="3" />
							</xsd:restriction>
						</xsd:simpleType>
					</xsd:element>
					<xsd:element name="Percent" type="Percent" />
				</xsd:sequence>
			</xsd:complexType>
			<xsd:complexType name="CashDiscountTerms">
				<xsd:sequence>
					<xsd:element name="PaymentBaselineDate" minOccurs="0"
						type="Date" />
					<xsd:element name="MaximumCashDiscount" minOccurs="0"
						type="CashDiscount" />
					<xsd:element name="NormalCashDiscount" minOccurs="0"
						type="CashDiscount" />
					<xsd:element name="FullPaymentDueDaysValue" minOccurs="0"
						type="xsd:integer" />
				</xsd:sequence>
			</xsd:complexType>
			<xsd:complexType name="CatalogueID">
				<xsd:simpleContent>
					<xsd:extension base="CatalogueIDContent">
						<xsd:attribute name="schemeID" type="xsd:token" />
						<xsd:attribute name="schemeAgencyID" type="xsd:token" />
						<xsd:attribute name="schemeAgencySchemeID" type="xsd:token" />
						<xsd:attribute name="schemeAgencySchemeAgencyID"
							type="xsd:token" />
					</xsd:extension>
				</xsd:simpleContent>
			</xsd:complexType>
			<xsd:simpleType name="CatalogueIDContent">
				<xsd:restriction base="xsd:token">
					<xsd:maxLength value="20" />
				</xsd:restriction>
			</xsd:simpleType>
			<xsd:simpleType name="CatalogueItemID">
				<xsd:restriction base="xsd:token">
					<xsd:maxLength value="40" />
				</xsd:restriction>
			</xsd:simpleType>
			<xsd:complexType name="CatalogueReference">
				<xsd:sequence>
					<xsd:element name="ID" type="CatalogueID" />
					<xsd:element name="ItemID" minOccurs="0" maxOccurs="unbounded"
						type="CatalogueItemID" />
				</xsd:sequence>
			</xsd:complexType>
			<xsd:simpleType name="CompleteTransmissionIndicator">
				<xsd:restriction base="xsd:boolean" />
			</xsd:simpleType>
			<xsd:complexType name="ContactPerson">
				<xsd:sequence>
					<xsd:element name="InternalID" minOccurs="0"
						type="ContactPersonInternalID" />
					<xsd:element name="BuyerID" minOccurs="0"
						type="ContactPersonPartyID" />
					<xsd:element name="SellerID" minOccurs="0"
						type="ContactPersonPartyID" />
					<xsd:element name="ProductRecipientID" minOccurs="0"
						type="ContactPersonPartyID" />
					<xsd:element name="VendorID" minOccurs="0"
						type="ContactPersonPartyID" />
					<xsd:element name="BillToID" minOccurs="0"
						type="ContactPersonPartyID" />
					<xsd:element name="BillFromID" minOccurs="0"
						type="ContactPersonPartyID" />
					<xsd:element name="BidderID" minOccurs="0"
						type="ContactPersonPartyID" />
					<xsd:element name="Address" minOccurs="0" type="Address" />
				</xsd:sequence>
			</xsd:complexType>
			<xsd:complexType name="ContactPersonInternalID">
				<xsd:simpleContent>
					<xsd:extension base="ContactPersonInternalIDContent">
						<xsd:attribute name="schemeID" type="xsd:token" />
						<xsd:attribute name="schemeAgencyID" type="xsd:token" />
					</xsd:extension>
				</xsd:simpleContent>
			</xsd:complexType>
			<xsd:simpleType name="ContactPersonInternalIDContent">
				<xsd:restriction base="xsd:token">
					<xsd:maxLength value="32" />
				</xsd:restriction>
			</xsd:simpleType>
			<xsd:simpleType name="ContactPersonPartyID">
				<xsd:restriction base="xsd:token">
					<xsd:maxLength value="60" />
				</xsd:restriction>
			</xsd:simpleType>
			<xsd:simpleType name="CountryCode">
				<xsd:restriction base="xsd:token">
					<xsd:length value="3" />
				</xsd:restriction>
			</xsd:simpleType>
			<xsd:simpleType name="Date">
				<xsd:restriction base="xsd:date" />
			</xsd:simpleType>
			<xsd:simpleType name="DateTime">
				<xsd:restriction base="xsd:string" />
			</xsd:simpleType>
			<xsd:complexType name="DateTimePeriod">
				<xsd:sequence>
					<xsd:element name="StartDateTime" minOccurs="0" type="DateTime" />
					<xsd:element name="EndDateTime" minOccurs="0" type="DateTime" />
					<xsd:element name="Duration" minOccurs="0" type="Duration" />
				</xsd:sequence>
			</xsd:complexType>
			<xsd:complexType name="DeliveryTerms">
				<xsd:sequence>
					<xsd:element name="Incoterms" minOccurs="0" type="Incoterms" />
					<xsd:element name="MaximumLeadTimeDuration" minOccurs="0"
						type="Duration" />
					<xsd:element name="Transport" minOccurs="0">
						<xsd:complexType>
							<xsd:sequence>
								<xsd:element name="ServiceLevelCode" minOccurs="0"
									type="TransportServiceLevelCode" />
								<xsd:element name="ModeCode" minOccurs="0"
									type="TransportModeCode" />
								<xsd:element name="MeansDescriptionCode" minOccurs="0"
									type="TransportMeansDescriptionCode" />
							</xsd:sequence>
						</xsd:complexType>
					</xsd:element>
					<xsd:element name="Description" minOccurs="0" type="Description" />
				</xsd:sequence>
			</xsd:complexType>
			<xsd:complexType name="Description">
				<xsd:simpleContent>
					<xsd:extension base="xsd:string">
						<xsd:attribute name="languageCode" type="xsd:language" />
					</xsd:extension>
				</xsd:simpleContent>
			</xsd:complexType>
			<xsd:simpleType name="Duration">
				<xsd:restriction base="xsd:string" />
			</xsd:simpleType>
			<xsd:complexType name="EmailAddress">
				<xsd:simpleContent>
					<xsd:extension base="xsd:anyURI">
						<xsd:attribute name="protocolCode" type="xsd:token" />
					</xsd:extension>
				</xsd:simpleContent>
			</xsd:complexType>
			<xsd:simpleType name="EvaluatedReceiptSettlementIndicator">
				<xsd:restriction base="xsd:boolean" />
			</xsd:simpleType>
			<xsd:complexType name="ExchangeFaultData">
				<xsd:sequence>
					<xsd:element name="faultText" type="xsd:string" />
					<xsd:element name="faultUrl" minOccurs="0" type="xsd:string" />
					<xsd:element name="faultDetail" minOccurs="0"
						maxOccurs="unbounded" type="ExchangeLogData" />
				</xsd:sequence>
			</xsd:complexType>
			<xsd:complexType name="ExchangeLogData">
				<xsd:sequence>
					<xsd:element name="severity" minOccurs="0" type="xsd:string" />
					<xsd:element name="text" type="xsd:string" />
					<xsd:element name="url" minOccurs="0" type="xsd:string" />
					<xsd:element name="id" minOccurs="0" type="xsd:string" />
				</xsd:sequence>
			</xsd:complexType>
			<xsd:simpleType name="FollowUpBusinessTransactionDocumentRequirementCode">
				<xsd:restriction base="xsd:token">
					<xsd:length value="2" />
				</xsd:restriction>
			</xsd:simpleType>
			<xsd:complexType name="GeoCoordinates">
				<xsd:sequence>
					<xsd:element name="LatitudeMeasure" type="Measure" />
					<xsd:element name="LongitudeMeasure" type="Measure" />
				</xsd:sequence>
			</xsd:complexType>
			<xsd:simpleType name="GoodsReceiptBasedInvoiceVerificationIndicator">
				<xsd:restriction base="xsd:boolean" />
			</xsd:simpleType>
			<xsd:complexType name="Incoterms">
				<xsd:sequence>
					<xsd:element name="ClassificationCode">
						<xsd:simpleType>
							<xsd:restriction base="xsd:token">
								<xsd:length value="3" />
							</xsd:restriction>
						</xsd:simpleType>
					</xsd:element>
					<xsd:element name="TransferLocationName" minOccurs="0">
						<xsd:simpleType>
							<xsd:restriction base="xsd:string">
								<xsd:maxLength value="28" />
							</xsd:restriction>
						</xsd:simpleType>
					</xsd:element>
				</xsd:sequence>
			</xsd:complexType>
			<xsd:simpleType name="LanguageCode">
				<xsd:restriction base="xsd:language">
					<xsd:maxLength value="9" />
				</xsd:restriction>
			</xsd:simpleType>
			<xsd:complexType name="LocationInternalID">
				<xsd:simpleContent>
					<xsd:extension base="LocationInternalIDContent">
						<xsd:attribute name="schemeID" type="xsd:token" />
						<xsd:attribute name="schemeAgencyID" type="xsd:token" />
					</xsd:extension>
				</xsd:simpleContent>
			</xsd:complexType>
			<xsd:simpleType name="LocationInternalIDContent">
				<xsd:restriction base="xsd:string">
					<xsd:maxLength value="32" />
				</xsd:restriction>
			</xsd:simpleType>
			<xsd:simpleType name="LocationPartyID">
				<xsd:restriction base="xsd:token">
					<xsd:maxLength value="20" />
				</xsd:restriction>
			</xsd:simpleType>
			<xsd:complexType name="LocationStandardID">
				<xsd:simpleContent>
					<xsd:extension base="LocationStandardIDContent">
						<xsd:attribute name="schemeAgencyID" type="xsd:token"
							use="required" />
					</xsd:extension>
				</xsd:simpleContent>
			</xsd:complexType>
			<xsd:simpleType name="LocationStandardIDContent">
				<xsd:restriction base="xsd:token">
					<xsd:length value="13" />
				</xsd:restriction>
			</xsd:simpleType>
			<xsd:complexType name="Measure">
				<xsd:simpleContent>
					<xsd:extension base="MeasureContent">
						<xsd:attribute name="unitCode" type="xsd:token" use="required" />
					</xsd:extension>
				</xsd:simpleContent>
			</xsd:complexType>
			<xsd:simpleType name="MeasureContent">
				<xsd:restriction base="xsd:decimal">
					<xsd:totalDigits value="19" />
					<xsd:fractionDigits value="6" />
				</xsd:restriction>
			</xsd:simpleType>
			<xsd:simpleType name="Note">
				<xsd:restriction base="xsd:string" />
			</xsd:simpleType>
			<xsd:complexType name="PartyInternalID">
				<xsd:simpleContent>
					<xsd:extension base="PartyInternalIDContent">
						<xsd:attribute name="schemeID" type="xsd:token" />
						<xsd:attribute name="schemeAgencyID" type="xsd:token" />
					</xsd:extension>
				</xsd:simpleContent>
			</xsd:complexType>
			<xsd:simpleType name="PartyInternalIDContent">
				<xsd:restriction base="xsd:token">
					<xsd:maxLength value="32" />
				</xsd:restriction>
			</xsd:simpleType>
			<xsd:simpleType name="PartyPartyID">
				<xsd:restriction base="xsd:token">
					<xsd:maxLength value="10" />
				</xsd:restriction>
			</xsd:simpleType>
			<xsd:complexType name="PartyStandardID">
				<xsd:simpleContent>
					<xsd:extension base="PartyStandardIDContent">
						<xsd:attribute name="schemeAgencyID" type="xsd:token"
							use="required" />
					</xsd:extension>
				</xsd:simpleContent>
			</xsd:complexType>
			<xsd:simpleType name="PartyStandardIDContent">
				<xsd:restriction base="xsd:token">
					<xsd:maxLength value="60" />
				</xsd:restriction>
			</xsd:simpleType>
			<xsd:complexType name="PartyTaxID">
				<xsd:simpleContent>
					<xsd:extension base="PartyTaxIDContent">
						<xsd:attribute name="schemeID" type="xsd:token" use="required" />
					</xsd:extension>
				</xsd:simpleContent>
			</xsd:complexType>
			<xsd:simpleType name="PartyTaxIDContent">
				<xsd:restriction base="xsd:token">
					<xsd:maxLength value="20" />
				</xsd:restriction>
			</xsd:simpleType>
			<xsd:complexType name="PaymentCard">
				<xsd:sequence>
					<xsd:element name="ID" type="PaymentCardID" />
					<xsd:element name="ReferenceID" minOccurs="0">
						<xsd:simpleType>
							<xsd:restriction base="xsd:token">
								<xsd:maxLength value="25" />
							</xsd:restriction>
						</xsd:simpleType>
					</xsd:element>
					<xsd:element name="SequenceID" minOccurs="0">
						<xsd:simpleType>
							<xsd:restriction base="xsd:token">
								<xsd:maxLength value="10" />
							</xsd:restriction>
						</xsd:simpleType>
					</xsd:element>
					<xsd:element name="Holder" minOccurs="0">
						<xsd:simpleType>
							<xsd:restriction base="xsd:string">
								<xsd:maxLength value="40" />
							</xsd:restriction>
						</xsd:simpleType>
					</xsd:element>
					<xsd:element name="ExpirationDate" type="Date" />
				</xsd:sequence>
			</xsd:complexType>
			<xsd:complexType name="PaymentCardID">
				<xsd:simpleContent>
					<xsd:extension base="PaymentCardIDContent">
						<xsd:attribute name="schemeID" type="xsd:token" use="required" />
						<xsd:attribute name="schemeAgencyID" type="xsd:token"
							use="required" />
						<xsd:attribute name="schemeAgencySchemeID" type="xsd:token" />
						<xsd:attribute name="schemeAgencySchemeAgencyID"
							type="xsd:token" />
					</xsd:extension>
				</xsd:simpleContent>
			</xsd:complexType>
			<xsd:simpleType name="PaymentCardIDContent">
				<xsd:restriction base="xsd:token">
					<xsd:maxLength value="25" />
				</xsd:restriction>
			</xsd:simpleType>
			<xsd:simpleType name="PaymentFormCode">
				<xsd:restriction base="xsd:token">
					<xsd:length value="2" />
				</xsd:restriction>
			</xsd:simpleType>
			<xsd:simpleType name="Percent">
				<xsd:restriction base="xsd:decimal">
					<xsd:totalDigits value="10" />
					<xsd:fractionDigits value="6" />
				</xsd:restriction>
			</xsd:simpleType>
			<xsd:complexType name="PersonName">
				<xsd:sequence>
					<xsd:element name="FormattedName" minOccurs="0">
						<xsd:simpleType>
							<xsd:restriction base="xsd:string">
								<xsd:maxLength value="80" />
							</xsd:restriction>
						</xsd:simpleType>
					</xsd:element>
					<xsd:element name="LegalName" minOccurs="0">
						<xsd:simpleType>
							<xsd:restriction base="xsd:string">
								<xsd:maxLength value="80" />
							</xsd:restriction>
						</xsd:simpleType>
					</xsd:element>
					<xsd:element name="GivenName" minOccurs="0" maxOccurs="unbounded" />
					<xsd:element name="PreferredGivenName" minOccurs="0">
						<xsd:simpleType>
							<xsd:restriction base="xsd:string">
								<xsd:maxLength value="40" />
							</xsd:restriction>
						</xsd:simpleType>
					</xsd:element>
					<xsd:element name="MiddleName" minOccurs="0" maxOccurs="unbounded" />
					<xsd:element name="Family" minOccurs="0" maxOccurs="unbounded">
						<xsd:complexType>
							<xsd:sequence>
								<xsd:element name="FamilyName">
									<xsd:simpleType>
										<xsd:restriction base="xsd:string">
											<xsd:maxLength value="40" />
										</xsd:restriction>
									</xsd:simpleType>
								</xsd:element>
								<xsd:element name="PrimaryIndicator" minOccurs="0"
									type="xsd:boolean" />
								<xsd:element name="FamilyNamePrefix" minOccurs="0">
									<xsd:simpleType>
										<xsd:restriction base="xsd:string">
											<xsd:maxLength value="20" />
										</xsd:restriction>
									</xsd:simpleType>
								</xsd:element>
							</xsd:sequence>
						</xsd:complexType>
					</xsd:element>
					<xsd:element name="Affix" minOccurs="0" maxOccurs="unbounded">
						<xsd:complexType>
							<xsd:sequence>
								<xsd:element name="AffixName">
									<xsd:simpleType>
										<xsd:restriction base="xsd:string">
											<xsd:maxLength value="20" />
										</xsd:restriction>
									</xsd:simpleType>
								</xsd:element>
								<xsd:element name="AffixCode">
									<xsd:simpleType>
										<xsd:restriction base="xsd:token">
											<xsd:maxLength value="20" />
										</xsd:restriction>
									</xsd:simpleType>
								</xsd:element>
							</xsd:sequence>
						</xsd:complexType>
					</xsd:element>
				</xsd:sequence>
			</xsd:complexType>
			<xsd:complexType name="PhoneNumber">
				<xsd:sequence>
					<xsd:element name="AreaID" minOccurs="0">
						<xsd:simpleType>
							<xsd:restriction base="xsd:token">
								<xsd:maxLength value="10" />
							</xsd:restriction>
						</xsd:simpleType>
					</xsd:element>
					<xsd:element name="SubscriberID" minOccurs="0">
						<xsd:simpleType>
							<xsd:restriction base="xsd:token">
								<xsd:maxLength value="30" />
							</xsd:restriction>
						</xsd:simpleType>
					</xsd:element>
					<xsd:element name="ExtensionID" minOccurs="0">
						<xsd:simpleType>
							<xsd:restriction base="xsd:token">
								<xsd:maxLength value="10" />
							</xsd:restriction>
						</xsd:simpleType>
					</xsd:element>
					<xsd:element name="CountryCode" minOccurs="0" type="CountryCode" />
				</xsd:sequence>
			</xsd:complexType>
			<xsd:complexType name="Price">
				<xsd:sequence>
					<xsd:element name="Amount" type="Amount" />
					<xsd:element name="BaseQuantity" type="Quantity" />
				</xsd:sequence>
			</xsd:complexType>
			<xsd:complexType name="ProductCategoryInternalID">
				<xsd:simpleContent>
					<xsd:extension base="ProductCategoryInternalIDContent">
						<xsd:attribute name="schemeID" type="xsd:token" />
						<xsd:attribute name="schemeAgencyID" type="xsd:token" />
					</xsd:extension>
				</xsd:simpleContent>
			</xsd:complexType>
			<xsd:simpleType name="ProductCategoryInternalIDContent">
				<xsd:restriction base="xsd:string">
					<xsd:maxLength value="40" />
				</xsd:restriction>
			</xsd:simpleType>
			<xsd:simpleType name="ProductCategoryPartyID">
				<xsd:restriction base="xsd:token">
					<xsd:maxLength value="40" />
				</xsd:restriction>
			</xsd:simpleType>
			<xsd:complexType name="ProductCategoryStandardID">
				<xsd:simpleContent>
					<xsd:extension base="ProductCategoryStandardIDContent">
						<xsd:attribute name="schemeID" type="xsd:token" />
						<xsd:attribute name="schemeVersionID" type="xsd:token" />
						<xsd:attribute name="schemeAgencyID" type="xsd:token"
							use="required" />
					</xsd:extension>
				</xsd:simpleContent>
			</xsd:complexType>
			<xsd:simpleType name="ProductCategoryStandardIDContent">
				<xsd:restriction base="xsd:token">
					<xsd:maxLength value="40" />
				</xsd:restriction>
			</xsd:simpleType>
			<xsd:complexType name="ProductInternalID">
				<xsd:simpleContent>
					<xsd:extension base="ProductInternalIDContent">
						<xsd:attribute name="schemeID" type="xsd:token" />
						<xsd:attribute name="schemeAgencyID" type="xsd:token" />
					</xsd:extension>
				</xsd:simpleContent>
			</xsd:complexType>
			<xsd:simpleType name="ProductInternalIDContent">
				<xsd:restriction base="xsd:string">
					<xsd:maxLength value="60" />
				</xsd:restriction>
			</xsd:simpleType>
			<xsd:simpleType name="ProductPartyID">
				<xsd:restriction base="xsd:token">
					<xsd:maxLength value="60" />
				</xsd:restriction>
			</xsd:simpleType>
			<xsd:complexType name="ProductStandardID">
				<xsd:simpleContent>
					<xsd:extension base="ProductStandardIDContent">
						<xsd:attribute name="schemeID" type="xsd:token" />
						<xsd:attribute name="schemeAgencyID" type="xsd:token"
							use="required" />
					</xsd:extension>
				</xsd:simpleContent>
			</xsd:complexType>
			<xsd:simpleType name="ProductStandardIDContent">
				<xsd:restriction base="xsd:token">
					<xsd:maxLength value="40" />
				</xsd:restriction>
			</xsd:simpleType>
			<xsd:simpleType name="ProductTypeCode">
				<xsd:restriction base="xsd:token">
					<xsd:maxLength value="2" />
				</xsd:restriction>
			</xsd:simpleType>
			<xsd:complexType name="PurchaseOrder">
				<xsd:sequence>
					<xsd:element name="ID" type="BusinessTransactionDocumentID" />
					<xsd:element name="SellerID" minOccurs="0"
						type="BusinessTransactionDocumentID" />
					<xsd:element name="BuyerPostingDateTime" minOccurs="0"
						type="DateTime" />
					<xsd:element name="BuyerLastChangeDateTime" minOccurs="0"
						type="DateTime" />
					<xsd:element name="SellerPostingDateTime" minOccurs="0"
						type="DateTime" />
					<xsd:element name="SellerLastChangeDateTime" minOccurs="0"
						type="DateTime" />
					<xsd:element name="AcceptanceStatusCode" minOccurs="0"
						type="AcceptanceStatusCode" />
					<xsd:element name="ActionCode" type="ActionCode" />
					<xsd:element name="Note" minOccurs="0" type="Note" />
					<xsd:element name="ItemListCompleteTransmissionIndicator"
						minOccurs="0" type="CompleteTransmissionIndicator" />
					<xsd:element name="BuyerParty" minOccurs="0"
						type="BusinessTransactionDocumentParty" />
					<xsd:element name="SellerParty" minOccurs="0"
						type="BusinessTransactionDocumentParty" />
					<xsd:element name="ProductRecipientParty" minOccurs="0"
						type="BusinessTransactionDocumentParty" />
					<xsd:element name="VendorParty" minOccurs="0"
						type="BusinessTransactionDocumentParty" />
					<xsd:element name="ManufacturerParty" minOccurs="0"
						type="BusinessTransactionDocumentParty" />
					<xsd:element name="BillToParty" minOccurs="0"
						type="BusinessTransactionDocumentParty" />
					<xsd:element name="PayerParty" minOccurs="0"
						type="BusinessTransactionDocumentParty" />
					<xsd:element name="CarrierParty" minOccurs="0"
						type="BusinessTransactionDocumentParty" />
					<xsd:element name="ShipToLocation" minOccurs="0"
						type="BusinessTransactionDocumentShipToLocation" />
					<xsd:element name="ShipFromLocation" minOccurs="0"
						type="BusinessTransactionDocumentShipFromLocation" />
					<xsd:element name="DeliveryTerms" minOccurs="0"
						type="DeliveryTerms" />
					<xsd:element name="CashDiscountTerms" minOccurs="0"
						type="CashDiscountTerms" />
					<xsd:element name="PaymentForm" minOccurs="0">
						<xsd:complexType>
							<xsd:sequence>
								<xsd:element name="Code" type="PaymentFormCode" />
								<xsd:element name="PaymentCard" minOccurs="0"
									type="PaymentCard" />
							</xsd:sequence>
						</xsd:complexType>
					</xsd:element>
					<xsd:element name="Price" minOccurs="0">
						<xsd:complexType>
							<xsd:sequence>
								<xsd:element name="NetAmount" minOccurs="0" type="Amount" />
							</xsd:sequence>
						</xsd:complexType>
					</xsd:element>
					<xsd:element name="Attachment" minOccurs="0" maxOccurs="unbounded"
						type="Attachment" />
					<xsd:element name="AttachmentWebAddress" minOccurs="0"
						maxOccurs="unbounded" type="AttachmentWebAddress" />
					<xsd:element name="Description" minOccurs="0" type="Description" />
					<xsd:element name="ConfirmationDescription" minOccurs="0"
						type="Description" />
					<xsd:element name="FollowUpPurchaseOrderConfirmation"
						minOccurs="0">
						<xsd:complexType>
							<xsd:sequence>
								<xsd:element name="RequirementCode"
									type="FollowUpBusinessTransactionDocumentRequirementCode" />
							</xsd:sequence>
						</xsd:complexType>
					</xsd:element>
					<xsd:element name="FollowUpDespatchedDeliveryNotification"
						minOccurs="0">
						<xsd:complexType>
							<xsd:sequence>
								<xsd:element name="RequirementCode"
									type="FollowUpBusinessTransactionDocumentRequirementCode" />
							</xsd:sequence>
						</xsd:complexType>
					</xsd:element>
					<xsd:element name="FollowUpServiceAcknowledgementRequest"
						minOccurs="0">
						<xsd:complexType>
							<xsd:sequence>
								<xsd:element name="RequirementCode"
									type="FollowUpBusinessTransactionDocumentRequirementCode" />
							</xsd:sequence>
						</xsd:complexType>
					</xsd:element>
					<xsd:element name="FollowUpInvoiceRequest" minOccurs="0">
						<xsd:complexType>
							<xsd:sequence>
								<xsd:element name="RequirementCode" minOccurs="0"
									type="FollowUpBusinessTransactionDocumentRequirementCode" />
								<xsd:element name="EvaluatedReceiptSettlementIndicator"
									minOccurs="0" type="EvaluatedReceiptSettlementIndicator" />
							</xsd:sequence>
						</xsd:complexType>
					</xsd:element>
					<xsd:element name="Item" minOccurs="0" maxOccurs="unbounded"
						type="PurchaseOrderItem" />
				</xsd:sequence>
			</xsd:complexType>
			<xsd:complexType name="PurchaseOrderItem">
				<xsd:sequence>
					<xsd:element name="ID" minOccurs="0"
						type="BusinessTransactionDocumentItemID" />
					<xsd:element name="SellerID" minOccurs="0"
						type="BusinessTransactionDocumentItemID" />
					<xsd:element name="ActionCode" type="ActionCode" />
					<xsd:element name="AcceptanceStatusCode" minOccurs="0"
						type="AcceptanceStatusCode" />
					<xsd:element name="UnplannedItemPermissionCode"
						minOccurs="0" type="UnplannedItemPermissionCode" />
					<xsd:element name="UnconfirmedQuantityCancelledIndicator"
						minOccurs="0" type="CancelledIndicator" />
					<xsd:element name="GoodsReceiptBasedInvoiceVerificationIndicator"
						minOccurs="0" type="GoodsReceiptBasedInvoiceVerificationIndicator" />
					<xsd:element name="HierarchyRelationship" minOccurs="0">
						<xsd:complexType>
							<xsd:sequence>
								<xsd:element name="ParentItemID" minOccurs="0"
									type="BusinessTransactionDocumentItemID" />
								<xsd:element name="ParentItemSellerID" minOccurs="0"
									type="BusinessTransactionDocumentItemID" />
								<xsd:element name="TypeCode"
									type="BusinessTransactionDocumentItemHierarchyRelationshipTypeCode" />
							</xsd:sequence>
						</xsd:complexType>
					</xsd:element>
					<xsd:element name="Product" minOccurs="0"
						type="BusinessTransactionDocumentProduct" />
					<xsd:element name="ProductCategory" minOccurs="0"
						type="BusinessTransactionDocumentProductCategory" />
					<xsd:element name="Price" minOccurs="0">
						<xsd:complexType>
							<xsd:sequence>
								<xsd:element name="NetAmount" minOccurs="0" type="Amount" />
								<xsd:element name="NetUnitPrice" minOccurs="0" type="Price" />
							</xsd:sequence>
						</xsd:complexType>
					</xsd:element>
					<xsd:element name="ConfirmedPrice" minOccurs="0">
						<xsd:complexType>
							<xsd:sequence>
								<xsd:element name="NetUnitPrice" minOccurs="0" type="Price" />
							</xsd:sequence>
						</xsd:complexType>
					</xsd:element>
					<xsd:element name="BuyerParty" minOccurs="0"
						type="BusinessTransactionDocumentParty" />
					<xsd:element name="SellerParty" minOccurs="0"
						type="BusinessTransactionDocumentParty" />
					<xsd:element name="ProductRecipientParty" minOccurs="0"
						type="BusinessTransactionDocumentParty" />
					<xsd:element name="VendorParty" minOccurs="0"
						type="BusinessTransactionDocumentParty" />
					<xsd:element name="ManufacturerParty" minOccurs="0"
						type="BusinessTransactionDocumentParty" />
					<xsd:element name="BillToParty" minOccurs="0"
						type="BusinessTransactionDocumentParty" />
					<xsd:element name="PayerParty" minOccurs="0"
						type="BusinessTransactionDocumentParty" />
					<xsd:element name="CarrierParty" minOccurs="0"
						type="BusinessTransactionDocumentParty" />
					<xsd:element name="ShipToLocation" minOccurs="0"
						type="BusinessTransactionDocumentShipToLocation" />
					<xsd:element name="ShipFromLocation" minOccurs="0"
						type="BusinessTransactionDocumentShipFromLocation" />
					<xsd:element name="DeliveryTerms" minOccurs="0"
						type="DeliveryTerms" />
					<xsd:element name="QuoteReference" minOccurs="0"
						type="BusinessTransactionDocumentReference" />
					<xsd:element name="PurchaseContractReference"
						minOccurs="0" maxOccurs="unbounded" type="BusinessTransactionDocumentReference" />
					<xsd:element name="SalesContractReference" minOccurs="0"
						maxOccurs="unbounded" type="BusinessTransactionDocumentReference" />
					<xsd:element name="OriginPurchaseOrderReference"
						minOccurs="0" type="BusinessTransactionDocumentReference" />
					<xsd:element name="BuyerProductCatalogueReference"
						minOccurs="0" type="CatalogueReference" />
					<xsd:element name="SellerProductCatalogueReference"
						minOccurs="0" type="CatalogueReference" />
					<xsd:element name="Attachment" minOccurs="0" maxOccurs="unbounded"
						type="Attachment" />
					<xsd:element name="AttachmentWebAddress" minOccurs="0"
						maxOccurs="unbounded" type="AttachmentWebAddress" />
					<xsd:element name="Description" minOccurs="0" type="Description" />
					<xsd:element name="ConfirmationDescription" minOccurs="0"
						type="Description" />
					<xsd:element name="FollowUpPurchaseOrderConfirmation"
						minOccurs="0">
						<xsd:complexType>
							<xsd:sequence>
								<xsd:element name="RequirementCode"
									type="FollowUpBusinessTransactionDocumentRequirementCode" />
							</xsd:sequence>
						</xsd:complexType>
					</xsd:element>
					<xsd:element name="FollowUpDespatchedDeliveryNotification"
						minOccurs="0">
						<xsd:complexType>
							<xsd:sequence>
								<xsd:element name="RequirementCode"
									type="FollowUpBusinessTransactionDocumentRequirementCode" />
							</xsd:sequence>
						</xsd:complexType>
					</xsd:element>
					<xsd:element name="FollowUpServiceAcknowledgementRequest"
						minOccurs="0">
						<xsd:complexType>
							<xsd:sequence>
								<xsd:element name="RequirementCode"
									type="FollowUpBusinessTransactionDocumentRequirementCode" />
							</xsd:sequence>
						</xsd:complexType>
					</xsd:element>
					<xsd:element name="FollowUpInvoiceRequest" minOccurs="0">
						<xsd:complexType>
							<xsd:sequence>
								<xsd:element name="RequirementCode" minOccurs="0"
									type="FollowUpBusinessTransactionDocumentRequirementCode" />
								<xsd:element name="EvaluatedReceiptSettlementIndicator"
									minOccurs="0" type="EvaluatedReceiptSettlementIndicator" />
							</xsd:sequence>
						</xsd:complexType>
					</xsd:element>
					<xsd:element name="ScheduleLine" minOccurs="0"
						maxOccurs="unbounded" type="PurchaseOrderItemScheduleLine" />
					<xsd:element name="ConfirmedScheduleLine" minOccurs="0"
						maxOccurs="unbounded" type="PurchaseOrderItemScheduleLine" />
				</xsd:sequence>
			</xsd:complexType>
			<xsd:complexType name="PurchaseOrderItemScheduleLine">
				<xsd:sequence>
					<xsd:element name="ID" minOccurs="0"
						type="BusinessTransactionDocumentItemScheduleLineID" />
					<xsd:element name="SellerID" minOccurs="0"
						type="BusinessTransactionDocumentItemScheduleLineID" />
					<xsd:element name="DeliveryPeriod" type="DateTimePeriod" />
					<xsd:element name="Quantity" minOccurs="0" type="Quantity" />
				</xsd:sequence>
			</xsd:complexType>
			<xsd:complexType name="PurchaseOrderMessage">
				<xsd:sequence>
					<xsd:element name="MessageHeader" type="BusinessDocumentMessageHeader" />
					<xsd:element name="PurchaseOrder" type="PurchaseOrder" />
				</xsd:sequence>
			</xsd:complexType>
			<xsd:complexType name="Quantity">
				<xsd:simpleContent>
					<xsd:extension base="QuantityContent">
						<xsd:attribute name="unitCode" type="xsd:token" use="required" />
					</xsd:extension>
				</xsd:simpleContent>
			</xsd:complexType>
			<xsd:simpleType name="QuantityContent">
				<xsd:restriction base="xsd:decimal">
					<xsd:totalDigits value="19" />
					<xsd:fractionDigits value="6" />
				</xsd:restriction>
			</xsd:simpleType>
			<xsd:complexType name="RegionCode">
				<xsd:simpleContent>
					<xsd:extension base="RegionCodeContent">
						<xsd:attribute name="listID" type="xsd:token" />
						<xsd:attribute name="listVersionID" type="xsd:token" />
						<xsd:attribute name="listAgencyID" type="xsd:token" />
						<xsd:attribute name="listAgencySchemeID" type="xsd:token" />
						<xsd:attribute name="listAgencySchemeAgencyID" type="xsd:token" />
					</xsd:extension>
				</xsd:simpleContent>
			</xsd:complexType>
			<xsd:simpleType name="RegionCodeContent">
				<xsd:restriction base="xsd:token" />
			</xsd:simpleType>
			<xsd:complexType name="TaxJurisdictionCode">
				<xsd:simpleContent>
					<xsd:extension base="TaxJurisdictionCodeContent">
						<xsd:attribute name="listID" type="xsd:token" />
						<xsd:attribute name="listVersionID" type="xsd:token" />
						<xsd:attribute name="listAgencyID" type="xsd:token" />
						<xsd:attribute name="listAgencySchemeID" type="xsd:token" />
						<xsd:attribute name="listAgencySchemeAgencyID" type="xsd:token" />
					</xsd:extension>
				</xsd:simpleContent>
			</xsd:complexType>
			<xsd:simpleType name="TaxJurisdictionCodeContent">
				<xsd:restriction base="xsd:token">
					<xsd:maxLength value="15" />
				</xsd:restriction>
			</xsd:simpleType>
			<xsd:simpleType name="TimeZoneDifferenceValue">
				<xsd:restriction base="xsd:decimal">
					<xsd:totalDigits value="4" />
					<xsd:fractionDigits value="2" />
				</xsd:restriction>
			</xsd:simpleType>
			<xsd:simpleType name="TransportMeansDescriptionCode">
				<xsd:restriction base="xsd:token">
					<xsd:maxLength value="4" />
				</xsd:restriction>
			</xsd:simpleType>
			<xsd:simpleType name="TransportModeCode">
				<xsd:restriction base="xsd:token">
					<xsd:maxLength value="2" />
				</xsd:restriction>
			</xsd:simpleType>
			<xsd:simpleType name="TransportServiceLevelCode">
				<xsd:restriction base="xsd:token">
					<xsd:maxLength value="2" />
				</xsd:restriction>
			</xsd:simpleType>
			<xsd:simpleType name="UnplannedItemPermissionCode">
				<xsd:restriction base="xsd:token">
					<xsd:length value="2" />
				</xsd:restriction>
			</xsd:simpleType>
			<xsd:simpleType name="WebAddress">
				<xsd:restriction base="xsd:anyURI">
					<xsd:maxLength value="255" />
				</xsd:restriction>
			</xsd:simpleType>
		</xsd:schema>
		<xsd:schema targetNamespace="http://sap.com/xi/SRM/Basis/Global"
			xmlns="http://sap.com/xi/SRM/Basis/Global"
			xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:tns="http://www.example.org"  xmlns:tested="http://www.example.org" xmlns:Q1="http://sap.com/xi/Purchasing">
			<xsd:import namespace="" />
			<xsd:element name="StandardMessageFault">
				<xsd:complexType>
					<xsd:sequence>
						<xsd:element name="standard" type="xsd:string" />
					</xsd:sequence>
				</xsd:complexType>
			</xsd:element>
		</xsd:schema>
	</wsdl:types>
	<wsdl:message name="PurchaseOrderConfirmationRequest">
		<wsdl:part name="parameters" element="PurchaseOrderConfirmationRequest" />
	</wsdl:message>
	<wsdl:message name="PurchaseOrderConfirmationRequestResponse">
		<wsdl:part name="parameters"
			element="PurchaseOrderConfirmationRequestResponse" />
	</wsdl:message>
	<wsdl:message name="exception00">
		<wsdl:part name="exception00" element="n0:StandardMessageFault" />
	</wsdl:message>
	<wsdl:portType name="PurchaseOrderConfirmation">
		<wsdl:operation name="PurchaseOrderConfirmationRequestResponse_In">
			<wsdl:input message="PurchaseOrderConfirmationRequest" />
			<wsdl:output message="PurchaseOrderConfirmationRequestResponse" />
			<wsdl:fault name="exception00" message="exception00" />
		</wsdl:operation>
	</wsdl:portType>
	<wsdl:binding name="PurchaseOrderConfirmationSoapBinding"
		type="PurchaseOrderConfirmation">
		<soap:binding style="document"
			transport="http://schemas.xmlsoap.org/soap/http" />
		<wsdl:operation name="PurchaseOrderConfirmationRequestResponse_In">
			<soap:operation soapAction="" />
			<wsdl:input>
				<soap:body use="literal" />
			</wsdl:input>
			<wsdl:output>
				<soap:body use="literal" />
			</wsdl:output>
			<wsdl:fault name="exception00">
				<soap:fault name="exception00" use="literal" />
			</wsdl:fault>
		</wsdl:operation>
	</wsdl:binding>
	<wsdl:service name="PurchaseOrderConfirmationService">
		<wsdl:port name="PurchaseOrderConfirmationSoapBinding"
			binding="PurchaseOrderConfirmationSoapBinding">
			<soap:address
				location="http://SRM.ESApreview.sap.com:80/sap/bc/srt/xip/sap/PurchaseOrderConfirmation?sap-client=800" />
		</wsdl:port>
	</wsdl:service>
</wsdl:definitions>